DSA ASSIGNMENT-II

NAME : SNEHASISH BANIK

SEM: III (G)

SRN: R17CS403
SET: 7

1. Create a single linked list that has a priority field associated with the data stored in each
node. Perform search operation based on the priority of the node and delete that node from
the linked list.

#include<stdio.h>
#include<stdlib.h>

struct node
{
int data;
struct node *next;
};

void addLast(struct node **head, int val)

{
//create a new node
struct node *newNode = malloc(sizeof(struct node));
newNode->data = val;
newNode->next = NULL;

//if head is NULL, it is an empty list

if(*head == NULL)
*head = newNode;
//Otherwise, find the last node and add the newNode
else
{
struct node *lastNode = *head;

//last node's next address will be NULL.

while(lastNode->next != NULL)
{
lastNode = lastNode->next;
}

//add the newNode at the end of the linked list

 lastNode->next = newNode;
}

void deleteNode(struct node **head, int key)

{
//temp is used to freeing the memory
struct node *temp;

//key found on the head node.

//move to head node to the next and free the head.
if((*head)->data == key)
{
temp = *head; //backup to free the memory
*head = (*head)->next;
free(temp);
}
else
{
struct node *current = *head;
while(current->next != NULL)
{
//if yes, we need to delete the current->next node
if(current->next->data == key)
{
temp = current->next;
//node will be disconnected from the linked list.
current->next = current->next->next;
free(temp);
break;
}
//Otherwise, move the current node and proceed
else
current = current->next;
}
}
}

void printList(struct node *head)

{
struct node *temp = head;

//iterate the entire linked list and print the data

while(temp != NULL)
{
printf("%d ->", temp->data);
temp = temp->next;
 }
printf("NULL\n");
}
int searchNode(struct node *head,int key)
{
struct node *temp = head;

//iterate the entire linked list and print the data

while(temp != NULL)
{
//key found return 1.
if(temp->data == key)
return 1;
temp = temp->next;
}
//key not found
return -1;
}

int main()
{
struct node *head = NULL;
int z,n;
while(1)
{
printf("\n Enter your choice \n");
printf("\n 1. add element \n");
printf("\n 2. delete element \n");
printf("\n 3. search element \n");
scanf("%d",&z);
if(z==1)
{
printf("\n enter elements to add\n");
scanf("%d",&n);
addLast(&head,n);
}
else if(z==2)
{
deleteNode(&head,n);
printf("Deleted . The New Linked List:\n");
printList(head);
}
else
{
int srch;
printf(" \n enter search element \n");
scanf("%d",&srch);
if(searchNode(head,srch) == 1)
 printf("Search Found\n");
else
printf("Search Not Found\n");
}
}

return 0;
}

OUTPUT
2. Write a C program to demonstrate min heap and max heap construction.

#include<bits/stdc++.h>
#include<stdio.h>
using namespace std;

void MaxHeapify(int arr[], int i, int n)

{
int l = 2*i + 1;
int r = 2*i + 2;
int largest = i;
if (l < n && arr[l] > arr[i])
largest = l;
if (r < n && arr[r] > arr[largest])
largest = r;
if (largest != i)
{
swap(arr[i], arr[largest]);
MaxHeapify(arr, largest, n);
}
}
void convertMaxHeap(int arr[], int n)
{
for (int i = (n-2)/2; i >= 0; --i)
MaxHeapify(arr, i, n);
}

void printArray(int* arr, int size)

{
for (int i = 0; i < size; ++i)
printf("%d ", arr[i]);
}

int main()
{
int arr[] = {3, 5, 9, 6, 8, 20, 10, 12, 18, 9};
int n = sizeof(arr)/sizeof(arr[0]);

printf("Min Heap array : ");

printArray(arr, n);

convertMaxHeap(arr, n);

printf("\nMax Heap array : ");

 printArray(arr, n);

return 0;
}

OUTPUT

3. Implement a singly linked list in C programming language that works like a stack.

// C program to Implement a stack

//using singly linked list
#include <stdio.h>
#include <stdlib.h>

// Declare linked list node

struct Node {
int data;
struct Node* link;
};
struct Node* top;

// Utility function to add an element data in the stack

// insert at the beginning
void push(int data)
{
 // create new node temp and allocate memory
struct Node* temp;
temp = (struct Node*)malloc(sizeof(struct Node));

// check if stack (heap) is full. Then inserting an element would

// lead to stack overflow
if (!temp) {
printf("\nHeap Overflow");
exit(1);
}

// initialize data into temp data field

temp->data = data;

// put top pointer reference into temp link

temp->link = top;

// make temp as top of Stack

top = temp;
}

// Utility function to check if the stack is empty or not

int isEmpty(struct Node* top)
{
return top == NULL;
}

// Utility function to return top element in a stack

int peek()
{
// check for empty stack
if (!isEmpty(top))
return top->data;
else
exit(EXIT_FAILURE);
}

// Utility function to pop top element from the stack

void pop()
{
struct Node* temp;

// check for stack underflow

 if (top == NULL) {
printf("\nStack Underflow");
exit(1);
}
else {
// top assign into temp
temp = top;

// assign second node to top

top = top->link;

// destroy connection between first and second

temp->link = NULL;

// release memory of top node

free(temp);
}
}

void display() // remove at the beginning

{
struct Node* temp;

// check for stack underflow

if (top == NULL) {
printf("\nStack Underflow");
exit(1);
}
else {
temp = top;
while (temp != NULL) {

// print node data

printf("%d->", temp->data);

// assign temp link to temp

temp = temp->link;
}
}
}

// main function

int main(void)
{
// push the elements of stack
push(11);
push(22);
push(33);
push(44);

// display stack elements

display();

// print top elementof stack

printf("\nTop element is %d\n", peek());

// delete top elements of stack

pop();
pop();

// display stack elements

display();

// print top elementof stack

printf("\nTop element is %d\n", peek());
return 0;
}

OUTPUT
4. Implement the following functions on Singly Linked List with Header Node.
a. searchKey(int key);
b. deleteKey(int key);
c. insertAfterKey(int elem, int key);
d. mergeTwoLists(NODE *, NODE *);

#include<stdio.h>
#include<stdlib.h>

struct node
{
int data;
struct node *next;
};

void addLast(struct node **head, int val)

{
//create a new node
struct node *newNode =(struct node *)malloc(sizeof(struct node));
newNode->data = val;
newNode->next = NULL;

//if head is NULL, it is an empty list

if(*head == NULL)
*head = newNode;
//Otherwise, find the last node and add the newNode
else
{
struct node *lastNode = *head;

//last node's next address will be NULL.

while(lastNode->next != NULL)
{
lastNode = lastNode->next;
}

//add the newNode at the end of the linked list

lastNode->next = newNode;
}

int searchNode(struct node *head,int key)

{
 struct node *temp = head;

//iterate the entire linked list and print the data

while(temp != NULL)
{
//key found return 1.
if(temp->data == key)
return 1;
temp = temp->next;
}
//key not found
return -1;
}
void deleteNode(struct node **head, int key)
{
//temp is used to freeing the memory
struct node *temp;

//key found on the head node.

//move to head node to the next and free the head.
if((*head)->data == key)
{
temp = *head; //backup to free the memory
*head = (*head)->next;
free(temp);
}
else
{
struct node *current = *head;
while(current->next != NULL)
{
//if yes, we need to delete the current->next node
if(current->next->data == key)
{
temp = current->next;
//node will be disconnected from the linked list.
current->next = current->next->next;
free(temp);
break;
}
//Otherwise, move the current node and proceed
else
current = current->next;
}
 }
}
void printList(struct node *head)
{
struct node *temp = head;

//iterate the entire linked list and print the data

while(temp != NULL)
{
printf("%d ->", temp->data);
temp = temp->next;
}
printf("NULL\n");
}
node *newNode(int key)
{
struct node *temp = new node;
temp->data = key;
temp->next = NULL;
return temp;
}
node *merge(node *h1, node *h2)
{
if (!h1)
return h2;
if (!h2)
return h1;

if (h1->data < h2->data)

{
h1->next = merge(h1->next, h2);
return h1;
}
else
{
h2->next = merge(h1, h2->next);
return h2;
}
}

int main()
{
struct node *head = NULL;
int ch,srch;
while(1)
{
printf("\n enter your choice \n");
printf(" 1.search \n 2.delete \n 3.insert \n 4.merge \n");
scanf("%d",&ch);
if(ch==1)
{
printf("\n enter value to search \n");
scanf("%d",&srch);
if(searchNode(head,srch) == 1)
printf("Search Found\n");
else
printf("Search Not Found\n");
}
else if(ch==2)
{
int del;
printf("\n enter value to delete \n");
scanf("%d",&del);
deleteNode(&head,del);
printList(head);
}
else if(ch==3)
{
int insert;
printf("\n enter value to insert \n");
scanf("%d",&insert);
addLast(&head,insert);
}
else if(ch==4)
{
printf(" inserting in the first list...(1,3,5) \n");
node *head1 = newNode(1);
head1->next = newNode(3);
head1->next->next = newNode(5);
printList(head1);
// 1->3->5 LinkedList created
printf(" inserting in the second list...(0,2,4) \n");
node *head2 = newNode(0);
head2->next = newNode(2);
head2->next->next = newNode(4);
printList(head2);
// 0->2->4 LinkedList created
 node *mergedhead = merge(head1, head2);
printf("\n THE FINAL MERGE LIST IS : \n ");
printList(mergedhead);
}
else
{
printf("\n wrong choice \n");
}
}
return 0;
}

OUTPUT
5. Write a menu driven C program to demonstrate functions insertion, deletion on Circular
Doubly Linked List.

// C program to delete a given key from

// linked list.
#include<stdio.h>
#include<stdlib.h>

/* structure for a node */

struct Node
{
int data;
struct Node *next;
};

/* Function to insert a node at the beginning of

a Circular linked list */
void push(struct Node **head_ref, int data)
{
// Create a new node and make head as next
// of it.
struct Node *ptr1 =
(struct Node *)malloc(sizeof(struct Node));
ptr1->data = data;
ptr1->next = *head_ref;

/* If linked list is not NULL then set the

 next of last node */
if (*head_ref != NULL)
{
// Find the node before head and update
// next of it.
struct Node *temp = *head_ref;
while (temp->next != *head_ref)
temp = temp->next;
temp->next = ptr1;
}
else
ptr1->next = ptr1; /*For the first node */

*head_ref = ptr1;
}

/* Function to print nodes in a given

circular linked list */
void printList(struct Node *head)
{
struct Node *temp = head;
if (head != NULL)
{
do
{
printf("%d ", temp->data);
temp = temp->next;
}
while (temp != head);
}

printf("\n");
}

/* Function to delete a given node from the list */

void deleteNode(struct Node *head, int key)
{
if (head == NULL)
return;

// Find the required node

struct Node *curr = head, *prev;
while (curr->data != key)
{
if (curr->next == head)
{
printf("\nGiven node is not found"
" in the list!!!");
 break;
}

prev = curr;
curr = curr -> next;
}

// Check if node is only node

if (curr->next == head)
{
head = NULL;
free(curr);
return;
}

// If more than one node, check if

// it is first node
if (curr == head)
{
prev = head;
while (prev -> next != head)
prev = prev -> next;
head = curr->next;
prev->next = head;
free(curr);
}

// check if node is last node

else if (curr -> next == head)
{
prev->next = head;
free(curr);
}
else
{
prev->next = curr->next;
free(curr);
}
}

/* Driver program to test above functions */

int main()
{
/* Initialize lists as empty */
struct Node *head = NULL;
int z;
while(1)
{
 printf("\n enter your choice \n 1. insert \n 2. delete \n");
scanf("%d",&z);
if(z==1)
{
int x;
printf("\n enter the value to insert \n");
scanf("%d",&x);
push(&head,x);
}
else
{
printf("List Before Deletion: ");
printList(head);
int f;
printf("\n enter the value to delete \n");
scanf("%d",&f);
deleteNode(head,f);
printf("List After Deletion: ");
printList(head);
}
}
return 0;
}

OUTPUT