Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
Scribd
Upload
15 views

C Assignment

The document describes an assignment to write code to remove the first node containing a specified number from a doubly linked list. It provides code to create and manipulate the linked list, including functions to initialize the list, add nodes, remove nodes, and print the list. The main function calls removeData to remove the first node containing a given number, and then prints the updated list. removeData finds and removes the node by calling other provided functions.

Uploaded by

Shagun Dhiman
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
15 views

C Assignment

The document describes an assignment to write code to remove the first node containing a specified number from a doubly linked list. It provides code to create and manipulate the linked list, including functions to initialize the list, add nodes, remove nodes, and print the list. The main function calls removeData to remove the first node containing a given number, and then prints the updated list. removeData finds and removes the node by calling other provided functions.

Uploaded by

Shagun Dhiman
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 4

ASSIGNMENT 8

In this question, you have to write code to remove the first node in a doubly linked list
containing a specified number. The code to create the linked list is already given.

The main() function calls a function removeData(head,tail,n) to remove the first node
containing data n from the linked list.
Complete the code by writing the missing function. You can also write additional functions
which you may need.

#include <stdio.h>

#include <stdlib.h>

struct DoublyLinkedList {
int data;
struct DoublyLinkedList * prev;
struct DoublyLinkedList * next;
};
/*
--------------------------
Create a new node
--------------------------
*/
struct DoublyLinkedList * createNode(int n) {
struct DoublyLinkedList * newNodeptr;
newNodeptr = (struct DoublyLinkedList * )
malloc(sizeof(struct DoublyLinkedList));
newNodeptr -> data = n;
newNodeptr -> prev = NULL;
newNodeptr -> next = NULL;
return newNodeptr;
}

/*
--------------------------------
add a node at the end of a doubly linked list.
Tailptr is the address of the pointer to the end of the current list.
After adding the node, tail points to the new node inserted.
--------------------------------
*/

void appendNode(struct DoublyLinkedList ** tailptr, int n) {


struct DoublyLinkedList * newNode;
newNode = createNode(n);
newNode -> prev = * tailptr;
( * tailptr) -> next = newNode;
* tailptr = newNode;
}

void initializeList(
struct DoublyLinkedList ** headptr,
struct DoublyLinkedList ** tailptr,
int n) {
struct DoublyLinkedList * newNode;
newNode = createNode(n);
* headptr = newNode;
* tailptr = newNode;
return;
}

void printList(
struct DoublyLinkedList * head,
struct DoublyLinkedList * tail) {
struct DoublyLinkedList * curr = head;
while (curr != NULL) {
if (curr -> next != NULL)
printf("%d,", curr -> data);
else printf("%d", curr -> data);

curr = curr -> next;


}
return;
}

/*
--------------------------------
remove the node that ptr points to.
After removing the first node, we should reset head.
After removing the last node, we should reset tail.
--------------------------------
*/
void removeNode(
struct DoublyLinkedList ** headptr,
struct DoublyLinkedList ** tailptr,
struct DoublyLinkedList * ptr) {
if (ptr == * headptr) {
* headptr = ptr -> next;
( * headptr) -> prev = NULL;
} else {
if (ptr == * tailptr) {
* tailptr = ptr -> prev;
( * tailptr) -> next = NULL;
} else {
ptr -> prev -> next = ptr -> next;
ptr -> next -> prev = ptr -> prev;
}
}
free(ptr);
ptr = NULL;
return;
}

void removeData(
struct DoublyLinkedList ** headptr,
struct DoublyLinkedList ** tailptr,
int n) {
struct DoublyLinkedList * curr;
curr = * headptr;
while (curr != NULL && curr -> data != n) {
curr = curr -> next;
}
if (curr != NULL) {
removeNode(headptr, tailptr, curr);
}
return;
}

int main() {
int n;
int i = 0;
int m;
struct DoublyLinkedList * head, * tail;
scanf("%d", & n);
if (n <= 0) {
return 0;
}
scanf("%d", & m);
initializeList( & head, & tail, m);
for (i = 1; i < n; i++) {
/* read the remaining elements */
scanf("%d", & m);
appendNode( & tail, m);
}

scanf("%d", & n);


removeData( & head, & tail, n);
printList(head, tail);
return 0;
}
You are given a non-negative number less than 10000000 (1 followed by 7 zeroes). You
have to divide the number into the
following components, and print them in the following order.

1. The part of the number which is less than a thousand.


2. The part of the number which is between a thousand and a lakh (10^5)
3. The part of the number which is between a lakh and a crore (10^7)

You should terminate printing when no higher power of 10 is present to be printed.

#include<stdio.h>

int main() {
int num;
scanf("%d", &num);

int part1 = num % 1000;


printf("%d\n", part1);

int part2 = (num / 1000) % 100;


if (part2 != 0) {
printf("%d\n", part2);
}

int part3 = num / 100000;


if (part3 != 0) {
printf("%d\n", part3);
}

return 0;
}

You might also like