1. Write a program to implement the below CIRCULAR linked list operations. 1.

Insert in beginning 2. Insert at last 3. Insert at any random location 4. Delete from
Beginning 5. Delete from last 6. Delete node after specified location 7. Search for
an element 8. Show 9. Exit

CIRCULAR LINKED LIST

#include <stdio.h>

#include <stdlib.h>

struct Node {

int data;

struct Node* next;

};

struct Node* head = NULL;

void insertAtBeginning(int value) {

struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));

newNode->data = value;
 if (head == NULL) {

newNode->next = newNode; // Circular reference

head = newNode;

} else {

struct Node* temp = head;

while (temp->next != head) {

temp = temp->next;

temp->next = newNode;

newNode->next = head;

head = newNode;

printf("node inserted\n");

void insertAtEnd(int value) {

struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));

newNode->data = value;

if (head == NULL) {

newNode->next = newNode;

head = newNode;

} else {

struct Node* temp = head;

while (temp->next != head) {

temp = temp->next;

temp->next = newNode;
 newNode->next = head;

printf("node inserted\n");

void deleteFromBeginning() {

if (head == NULL) {

printf("List is empty, nothing to delete.\n");

return;

if (head->next == head) {

free(head);

head = NULL;

} else {

struct Node* temp = head;

struct Node* last = head;

while (last->next != head) {

last = last->next;

last->next = head->next;

head = head->next;

free(temp);

printf("node deleted\n");

}
void deleteFromEnd() {

if (head == NULL) {

printf("List is empty, nothing to delete.\n");

return;

if (head->next == head) {

free(head);

head = NULL;

} else {

struct Node* temp = head;

struct Node* prev = NULL;

while (temp->next != head) {

prev = temp;

temp = temp->next;

prev->next = head;

free(temp);

printf("node deleted\n");

void search(int value) {

if (head == NULL) {

printf("List is empty.\n");

return;

}
 struct Node* temp = head;

do {

if (temp->data == value) {

printf("Item found\n");

return;

temp = temp->next;

} while (temp != head);

printf("Item not found\n");

void show() {

if (head == NULL) {

printf("The list is empty.\n");

return;

struct Node* temp = head;

printf(" printing values ... \n");

do {

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

temp = temp->next;

} while (temp != head);

int main() {

int choice, value;

do {
printf("\n*********Main Menu*********\n\n");

printf("Choose one option from the following list ...\n\n");

printf("===============================================\n\n");

printf("1.Insert in begining\n");

printf("2.Insert at last\n");

printf("3.Delete from Beginning\n");

printf("4.Delete from last\n");

printf("5.Search for an element\n");

printf("6.Show\n");

printf("7.Exit\n\n");

printf("Enter your choice?\n\n");

scanf("%d", &choice);

switch (choice) {

case 1:

printf("Enter the node data?\n\n");

scanf("%d", &value);

insertAtBeginning(value);

break;

case 2:

printf("Enter Data?\n\n");

scanf("%d", &value);

insertAtEnd(value);

break;

case 3:

deleteFromBeginning();

break;

case 4:

deleteFromEnd();
 break;

case 5:

printf("\nEnter item which you want to search?\n\n");

scanf("%d", &value);

search(value);

break;

case 6:

show();

break;

case 7:

exit(0);

break;

default:

printf("Invalid choice.\n");

} while (choice != 7);

return 0;

2. Write a program to implement the below DOUBLY linked list operations. 1. Insert in beginning 2. Insert
at last 3. Insert at any random location 4. Delete from Beginning 5. Delete from last 6. Delete node after
specified location 7. Search for an element 8. Show 9. Exit

DOUBLY LINKED LIST

#include <stdio.h>

#include <stdlib.h>
struct Node {

int data;

struct Node* prev;

struct Node* next;

};

struct Node* createNode(int data) {

struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));

newNode->data = data;

newNode->prev = NULL;

newNode->next = NULL;

return newNode;

void insertAtBeginning(struct Node** head, int data) {

struct Node* newNode = createNode(data);

if (*head != NULL) {

newNode->next = *head;

(*head)->prev = newNode;

*head = newNode;

printf("Node inserted\n");

void insertAtEnd(struct Node** head, int data) {

struct Node* newNode = createNode(data);

if (*head == NULL) {

*head = newNode;

printf("node inserted\n");
 return;

struct Node* temp = *head;

while (temp->next != NULL) {

temp = temp->next;

temp->next = newNode;

newNode->prev = temp;

printf("node inserted\n");

void insertAtPosition(struct Node** head, int data, int position) {

if (position < 1) {

printf("Position should be >= 1.\n");

return;

if (position == 1) {

insertAtBeginning(head, data);

return;

struct Node* newNode = createNode(data);

struct Node* temp = *head;

for (int i = 1; i < position - 1 && temp != NULL; i++) {

temp = temp->next;

if (temp == NULL) {
 printf("Position does not exist. Node not inserted.\n");

free(newNode);

return;

newNode->next = temp->next;

if (temp->next != NULL) {

temp->next->prev = newNode;

temp->next = newNode;

newNode->prev = temp;

printf("node inserted\n");

void deleteFromBeginning(struct Node** head) {

if (*head == NULL) {

printf("List is empty. No nodes to delete.\n");

return;

struct Node* temp = *head;

*head = (*head)->next;

if (*head != NULL) {

(*head)->prev = NULL;

free(temp);

printf("node deleted\n");

void deleteFromEnd(struct Node** head) {

 if (*head == NULL) {

printf("List is empty. No nodes to delete.\n");

return;

struct Node* temp = *head;

while (temp->next != NULL) {

temp = temp->next;

if (temp->prev != NULL) {

temp->prev->next = NULL;

} else {

*head = NULL; // If there was only one node

free(temp);

printf("node deleted\n");

void deleteAfterNode(struct Node** head, int key) {

struct Node* temp = *head;

while (temp != NULL && temp->data != key) {

temp = temp->next;

if (temp == NULL || temp->next == NULL) {

printf("Node not found or no node to delete after it.\n");

return;

}
 struct Node* nodeToDelete = temp->next;

temp->next = nodeToDelete->next;

if (nodeToDelete->next != NULL) {

nodeToDelete->next->prev = temp;

free(nodeToDelete);

printf("node deleted\n");

void searchElement(struct Node* head, int key) {

struct Node* temp = head;

while (temp != NULL) {

if (temp->data == key) {

printf("Item found\n");

return;

temp = temp->next;

printf("Item not found\n");

// Function to display the list

void showList(struct Node* head) {

struct Node* temp = head;

if (temp == NULL) {

printf("List is empty.\n");

return;

printf("printing values...\n");
 while (temp != NULL) {

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

temp = temp->next;

printf("\n");

void displayMenu() {

printf("\n*********Main Menu*********\n\n");

printf("Choose one option from the following list ...\n\n");

printf("===============================================\n\n");

printf("1.Insert in begining\n");

printf("2.Insert at last\n");

printf("3.Insert at any random location\n");

printf("4.Delete from Beginning\n");

printf("5.Delete from last\n");

printf("6.Delete the node after the given data\n");

printf("7.Search\n");

printf("8.Show\n");

printf("9.Exit\n\n");

printf("Enter your choice?\n\n");

int main() {

struct Node* head = NULL;

int choice, data, position;

while (1) {

displayMenu();
scanf("%d", &choice);

switch (choice) {

case 1:

printf("Enter Item value\n\n");

scanf("%d", &data);

insertAtBeginning(&head, data);

break;

case 2:

printf("Enter value\n\n");

scanf("%d", &data);

insertAtEnd(&head, data);

break;

case 3:

printf("Enter the location\n\n");

scanf("%d", &position);

printf("Enter value\n\n");

scanf("%d", &data);

insertAtPosition(&head, data, position);

break;

case 4:

deleteFromBeginning(&head);

break;

case 5:

deleteFromEnd(&head);

break;

case 6:

printf("Enter the node value after which to delete\n\n");

scanf("%d", &data);
 deleteAfterNode(&head, data);

break;

case 7:

printf("Enter item which you want to search?\n");

scanf("%d", &data);

searchElement(head, data);

break;

case 8:

showList(head);

break;

case 9:

exit(0);

default:

printf("Invalid choice! Please try again.\n");

return 0;

3. Write a program to implement the tree traversal (In order, Preorder, Postorder) methods.

BINARY TREE TRAVERSAL

#include <stdio.h>

#include <stdlib.h>

struct Node {

int data;
 struct Node* left;

struct Node* right;

};

struct Node* createNode(int data) {

struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));

newNode->data = data;

newNode->left = NULL;

newNode->right = NULL;

return newNode;

struct Node* insertNode(struct Node* root, int data) {

if (root == NULL) {

return createNode(data); // Create the root node

if (data < root->data) {

root->left = insertNode(root->left, data);

} else {

root->right = insertNode(root->right, data);

return root;

void preorderTraversal(struct Node* node) {

if (node == NULL)

return;
 printf("%d ", node->data);

preorderTraversal(node->left);

preorderTraversal(node->right);

void inorderTraversal(struct Node* node) {

if (node == NULL)

return;

inorderTraversal(node->left);

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

inorderTraversal(node->right);

void postorderTraversal(struct Node* node) {

if (node == NULL)

return;

postorderTraversal(node->left);

postorderTraversal(node->right);

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

int main() {

struct Node* root = NULL;

char choice;

do {

int data;

printf("Enter data: ");

scanf("%d", &data);
 // Insert node into the binary tree

root = insertNode(root, data);

printf("Do you want to enter more (y/n)? ");

scanf(" %c", &choice);

} while (choice == 'y' || choice == 'Y');

printf("\nPreorder Traversal: ");

preorderTraversal(root);

printf("\n");

printf("Inorder Traversal: ");

inorderTraversal(root);

printf("\n");

printf("Postorder Traversal: ");

postorderTraversal(root);

printf("\n");

return 0;

4. Write a program for Binary Search Tree operations (Insert and Delete).

BINARY SEARCH TREE(BST)

#include <stdio.h>

#include <stdlib.h>
struct Node {

int data;

struct Node* left;

struct Node* right;

};

struct Node* createNode(int data) {

struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));

newNode->data = data;

newNode->left = NULL;

newNode->right = NULL;

return newNode;

struct Node* insertNode(struct Node* root, int data) {

if (root == NULL) {

return createNode(data); // Create new node if tree is empty

if (data < root->data) {

root->left = insertNode(root->left, data); // Insert in the left subtree

} else if (data > root->data) {

root->right = insertNode(root->right, data); // Insert in the right subtree

return root;

// Function to find the minimum value node in the BST

struct Node* findMin(struct Node* node) {

 struct Node* current = node;

while (current && current->left != NULL)

current = current->left; // Traverse to the leftmost leaf

return current;

struct Node* deleteNode(struct Node* root, int data) {

if (root == NULL)

return root;

if (data < root->data) {

root->left = deleteNode(root->left, data); // Traverse to the left subtree

} else if (data > root->data) {

root->right = deleteNode(root->right, data); // Traverse to the right subtree

} else {

if (root->left == NULL) {

struct Node* temp = root->right;

free(root);

return temp;

} else if (root->right == NULL) {

struct Node* temp = root->left;

free(root);

return temp;

struct Node* temp = findMin(root->right);

root->data = temp->data;

root->right = deleteNode(root->right, temp->data);

 }

return root;

void inorderTraversal(struct Node* node, int* count) {

if (node == NULL)

return;

inorderTraversal(node->left, count);

(*count)++;

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

if (*count != 8) {

printf(" -> ");

inorderTraversal(node->right, count);

int main() {

struct Node* root = NULL;

root = insertNode(root, 8);

root = insertNode(root, 3);

root = insertNode(root, 10);

root = insertNode(root, 1);

root = insertNode(root, 6);

root = insertNode(root, 4);

 root = insertNode(root, 7);

root = insertNode(root, 14);

// Initial Inorder Traversal

printf("Inorder traversal: ");

int count = 0;

inorderTraversal(root, &count);

printf(" -> \n");

// Delete node 10

root = deleteNode(root, 10);

printf("After deleting 10\n");

count = 0;

printf("Inorder traversal: ");

inorderTraversal(root, &count);

printf(" -> \n");

return 0;