#context

1. Stack(2-3)
2. Queue(3-4)
3. Linked List(5-16)
4. Binary Tree Traversal(16-17)
5. B+(17-20)
6. B-(20-23)
7. AVL(23-28)
8. Splay Tree(28-31)
9. Sequential Search(31-32)
10. Binary Search(32)
11. Breadth First Search(32-34)
12. Depth First Search(34-35)
13. Insertion Sort(35-36)
14. Sequential Search(36-37)
15. shell sort(37)
16. Merge Sort(37-39)
17. Quick Sort(39-40)
18. Heap Sort(40-41)
19. Krushal’s Algo.(41-42)
20. Prim’s Algo.(42-43)
21. Selection Sort(43-44)
22. TBT(44-46)
23. Dijkstra Algo(46-47)
24. Tower of Hanoi(47-48)
25. Doubly Linked List(48-52)
26. Circular Linked List(52-58)

SB
# stack
#include <stdio.h>
#include <stdlib.h>
#define MAX 100
typedef struct {
int top;
int arr[MAX];
} Stack;
void init(Stack *s) {
s->top = -1;
}
int isEmpty(Stack *s) {
return s->top == -1;
}
int isFull(Stack *s) {
return s->top == MAX - 1;
}
void push(Stack *s, int value) {
if (isFull(s)) {
printf("Stack Overflow!\n");
return;
}
s->arr[++(s->top)] = value;
printf("Pushed %d onto stack.\n", value);
}
int pop(Stack *s) {
if (isEmpty(s)) {
printf("Stack Underflow!\n");
return -1;
}
return s->arr[(s->top)--];
}
int peek(Stack *s) {
if (isEmpty(s)) {
printf("Stack is empty!\n");
return -1;
}
return s->arr[s->top];
}
void display(Stack *s) {
if (isEmpty(s)) {
printf("Stack is empty!\n");
return;
}
printf("Stack elements: ");
for (int i = 0; i <= s->top; i++) {
printf("%d ", s->arr[i]);
}
printf("\n");
}
int main() {
Stack s;
init(&s);
push(&s, 10);
push(&s, 20);
push(&s, 30);
display(&s);
printf("Top element: %d\n", peek(&s));
printf("Popped element: %d\n", pop(&s));
display(&s);
return 0;
}

# Queue
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include "LL.c"
typedef struct Queue {
LinkedList* list;
} Queue;
Queue* createQueue() {
Queue* queue = (Queue*)malloc(sizeof(Queue));
if (queue == NULL) {
return NULL;
}
queue->list = createList();
return queue;
}
bool enqueue(Queue* queue, int data) {
if (queue == NULL) {
return false;
}
return insertAtEnd(queue->list, data);
}
int dequeue(Queue* queue) {
if (queue == NULL || isEmpty(queue->list)) {
return -1;
}
int data = queue->list->head->data;
deleteFromBeginning(queue->list);
return data;
}
int peek(Queue* queue) {
if (queue == NULL || isEmpty(queue->list)) {
return -1;
}
return queue->list->head->data;
}
bool isQueueEmpty(Queue* queue) {
return isEmpty(queue->list);
}
int main() {
Queue* queue = createQueue();
printf("--- Queue Operations ---\n");
enqueue(queue, 10);
enqueue(queue, 20);
enqueue(queue, 30);
printf("Front element: %d\n", peek(queue));
printf("Dequeued: %d\n", dequeue(queue));
printf("Front element after dequeue: %d\n", peek(queue));
printf("Is queue empty? %s\n", isQueueEmpty(queue) ? "Yes" : "No");
freeList(queue->list);
free(queue);
return 0;
}

#Linked List
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

// Node structure
typedef struct Node {
int data;
struct Node* next;
} Node;

// Linked list structure

typedef struct {
Node* head;
size_t size;
} LinkedList;

// Function prototypes
LinkedList* createList();
void freeList(LinkedList* list);
void display(LinkedList* list);
bool isEmpty(LinkedList* list);
bool insertAtBeginning(LinkedList* list, int data);
bool insertAtEnd(LinkedList* list, int data);
bool insertAtPosition(LinkedList* list, int data, size_t position);
bool deleteFromBeginning(LinkedList* list);
bool deleteFromEnd(LinkedList* list);
bool deleteFromPosition(LinkedList* list, size_t position);
bool deleteByValue(LinkedList* list, int data);
Node* search(LinkedList* list, int data);
int countOccurrences(LinkedList* list, int data);
bool update(LinkedList* list, int oldData, int newData);
bool updateAtPosition(LinkedList* list, size_t position, int newData);
void sort(LinkedList* list);
LinkedList* merge(LinkedList* list1, LinkedList* list2);
void reverse(LinkedList* list);

// Create a new empty linked list

LinkedList* createList() {
LinkedList* list = (LinkedList*)malloc(sizeof(LinkedList));
if (list == NULL) {
return NULL;
}
list->head = NULL;
list->size = 0;
return list;
}

// Free the memory occupied by the linked list

void freeList(LinkedList* list) {
if (list == NULL) {
return;
}
Node* current = list->head;
Node* next;
while (current != NULL) {
next = current->next;
free(current);
current = next;
}
free(list);
}

// Check if the list is empty

bool isEmpty(LinkedList* list) {
return (list == NULL || list->head == NULL);
}

// Display all elements of the linked list

void display(LinkedList* list) {
if (isEmpty(list)) {
printf("List is empty.\n");
return;
}
Node* current = list->head;
printf("List (size = %zu): ", list->size);
while (current != NULL) {
printf("%d -> ", current->data);
current = current->next;
}
printf("NULL\n");
}
// Insert a node at the beginning of the list
bool insertAtBeginning(LinkedList* list, int data) {
if (list == NULL) {
return false;
}
Node* newNode = (Node*)malloc(sizeof(Node));
if (newNode == NULL) {
return false;
}
newNode->data = data;
newNode->next = list->head;
list->head = newNode;
list->size++;
return true;
}

// Insert a node at the end of the list

bool insertAtEnd(LinkedList* list, int data) {
if (list == NULL) {
return false;
}
Node* newNode = (Node*)malloc(sizeof(Node));
if (newNode == NULL) {
return false;
}
newNode->data = data;
newNode->next = NULL;
if (list->head == NULL) {
list->head = newNode;
} else {
Node* current = list->head;
while (current->next != NULL) {
current = current->next;
}
current->next = newNode;
}
list->size++;
return true;
}
// Insert a node at the specified position
bool insertAtPosition(LinkedList* list, int data, size_t position) {
if (list == NULL || position > list->size) {
return false;
}
if (position == 0) {
return insertAtBeginning(list, data);
}
if (position == list->size) {
return insertAtEnd(list, data);
}
Node* newNode = (Node*)malloc(sizeof(Node));
if (newNode == NULL) {
return false;
}
Node* current = list->head;
for (size_t i = 0; i < position - 1; i++) {
current = current->next;
}
newNode->data = data;
newNode->next = current->next;
current->next = newNode;
list->size++;
return true;
}

// Delete the first node

bool deleteFromBeginning(LinkedList* list) {
if (isEmpty(list)) {
return false;
}
Node* temp = list->head;
list->head = list->head->next;
free(temp);
list->size--;
return true;
}

// Delete the last node

bool deleteFromEnd(LinkedList* list) {
if (isEmpty(list)) {
return false;
}
if (list->head->next == NULL) {
free(list->head);
list->head = NULL;
list->size--;
return true;
}
Node* current = list->head;
Node* prev = NULL;
while (current->next != NULL) {
prev = current;
current = current->next;
}
prev->next = NULL;
free(current);
list->size--;
return true;
}

// Delete a node at the specified position

bool deleteFromPosition(LinkedList* list, size_t position) {
if (isEmpty(list) || position >= list->size) {
return false;
}
if (position == 0) {
return deleteFromBeginning(list);
}
if (position == list->size - 1) {
return deleteFromEnd(list);
}
Node* current = list->head;
for (size_t i = 0; i < position - 1; i++) {
current = current->next;
}
Node* temp = current->next;
current->next = temp->next;
free(temp);
list->size--;
return true;
}

// Delete all nodes with the specified value

bool deleteByValue(LinkedList* list, int data) {
if (isEmpty(list)) {
return false;
}
bool deleted = false;
// Handle head deletions
while (list->head != NULL && list->head->data == data) {
Node* temp = list->head;
list->head = list->head->next;
free(temp);
list->size--;
deleted = true;
}
if (list->head == NULL) {
return deleted;
}
// Handle deletions in the rest of the list
Node* current = list->head;
while (current->next != NULL) {
if (current->next->data == data) {
Node* temp = current->next;
current->next = temp->next;
free(temp);
list->size--;
deleted = true;
// Don't move current pointer as we need to check the new next node
} else {
current = current->next;
}
}
return deleted;
}

// Search for a node with the specified value

Node* search(LinkedList* list, int data) {
if (isEmpty(list)) {
return NULL;
}
Node* current = list->head;
while (current != NULL) {
if (current->data == data) {
return current;
}
current = current->next;
}
return NULL;
}

// Count the number of occurrences of a value

int countOccurrences(LinkedList* list, int data) {
if (isEmpty(list)) {
return 0;
}
int count = 0;
Node* current = list->head;
while (current != NULL) {
if (current->data == data) {
count++;
}
current = current->next;
}
return count;
}

// Update the first occurrence of oldData to newData

bool update(LinkedList* list, int oldData, int newData) {
if (isEmpty(list)) {
return false;
}
Node* node = search(list, oldData);
if (node != NULL) {
node->data = newData;
return true;
}
return false;
}

// Update the data at the specified position

bool updateAtPosition(LinkedList* list, size_t position, int newData) {
if (isEmpty(list) || position >= list->size) {
return false;
}
Node* current = list->head;
for (size_t i = 0; i < position; i++) {
current = current->next;
}
current->data = newData;
return true;
}

// Sort the linked list using bubble sort algorithm

void sort(LinkedList* list) {
if (isEmpty(list) || list->size == 1) {
return;
}
bool swapped;
Node* current;
Node* last = NULL;
do {
swapped = false;
current = list->head;
while (current->next != last) {
if (current->data > current->next->data) {
// Swap the data
int temp = current->data;
current->data = current->next->data;
current->next->data = temp;
swapped = true;
}
current = current->next;
}
last = current;
} while (swapped);
}
// Merge two sorted lists into one sorted list
LinkedList* merge(LinkedList* list1, LinkedList* list2) {
if (list1 == NULL) {
return list2;
}
if (list2 == NULL) {
return list1;
}
// Make sure both lists are sorted
sort(list1);
sort(list2);
LinkedList* mergedList = createList();
if (mergedList == NULL) {
return NULL;
}
Node* current1 = list1->head;
Node* current2 = list2->head;
// Merge the two lists
while (current1 != NULL && current2 != NULL) {
if (current1->data <= current2->data) {
insertAtEnd(mergedList, current1->data);
current1 = current1->next;
} else {
insertAtEnd(mergedList, current2->data);
current2 = current2->next;
}
}
// Add any remaining elements
while (current1 != NULL) {
insertAtEnd(mergedList, current1->data);
current1 = current1->next;
}
while (current2 != NULL) {
insertAtEnd(mergedList, current2->data);
current2 = current2->next;
}
return mergedList;
}

// Reverse the linked list

void reverse(LinkedList* list) {
if (isEmpty(list) || list->size == 1) {
return;
}
Node* prev = NULL;
Node* current = list->head;
Node* next = NULL;
while (current != NULL) {
next = current->next; // Save the next node
current->next = prev; // Reverse the link
prev = current; // Move prev to current
current = next; // Move current to next
}
list->head = prev;
}

// Example main function to test the linked list operations

int main() {
LinkedList* list = createList();
printf("--- Insertion Tests ---\n");
insertAtBeginning(list, 10);
insertAtEnd(list, 30);
insertAtPosition(list, 20, 1);
insertAtEnd(list, 40);
insertAtBeginning(list, 5);
display(list);
printf("\n--- Search Tests ---\n");
Node* found = search(list, 20);
printf("Search for 20: %s\n", found ? "Found" : "Not found");
printf("Search for 25: %s\n", search(list, 25) ? "Found" : "Not found");
printf("\n--- Update Tests ---\n");
update(list, 30, 35);
updateAtPosition(list, 3, 45);
display(list);
printf("\n--- Delete Tests ---\n");
deleteFromBeginning(list);
display(list);
deleteFromEnd(list);
display(list);
deleteFromPosition(list, 1);
display(list);
printf("\n--- Insert More Data ---\n");
insertAtEnd(list, 25);
insertAtEnd(list, 25);
insertAtEnd(list, 15);
display(list);
printf("\n--- Delete by Value Tests ---\n");
deleteByValue(list, 25);
display(list);
printf("\n--- Sorting Test ---\n");
sort(list);
display(list);
printf("\n--- Reverse Test ---\n");
reverse(list);
display(list);
printf("\n--- Merge Test ---\n");
LinkedList* list2 = createList();
insertAtEnd(list2, 7);
insertAtEnd(list2, 14);
insertAtEnd(list2, 21);
printf("List 2: ");
display(list2);
LinkedList* mergedList = merge(list, list2);
printf("Merged list: ");
display(mergedList);
// Clean up
freeList(list);
freeList(list2);
freeList(mergedList);
return 0;
}
# BinaryTreeTraversal
#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;
}
void inorderTraversal(struct Node* root){
if(root==NULL){
return;
}
inorderTraversal(root->left);
printf("%d ",root->data);
inorderTraversal(root->right);
}
void preorderTraversal(struct Node* root){
if(root == NULL){
return;
}
printf("%d ",root->data);
preorderTraversal(root->left);
preorderTraversal(root->right);
}
void postorder(struct Node* root){
if(root == NULL){
return;
}
postorder(root->left);
postorder(root->right);
printf("%d ",root->data);
}
int main(){
struct Node* root = createnode(10);
root->left = createnode(20);
root->right = createnode(30);
root->left->left = createnode(40);
root->left->right = createnode(50);
root->right->left = createnode(60);
root->right->right = createnode(70);

printf("Inorder: ");
inorderTraversal(root);
printf("\n");

printf("Preorder: ");
preorderTraversal(root);
printf("\n");

printf("Postorder: ");
postorder(root);
printf("\n");
}
#B+
#include <stdio.h>
#include <stdlib.h>
#define MAX_KEYS 3
#define MIN_KEYS (MAX_KEYS / 2)
struct BPlusNode {
int keys[MAX_KEYS];
struct BPlusNode *children[MAX_KEYS + 1];
struct BPlusNode *next;
int num_keys;
int leaf;
};
struct BPlusNode *createNode(int leaf) {
struct BPlusNode *node = (struct BPlusNode *)malloc(sizeof(struct BPlusNode));
node->num_keys = 0;
node->leaf = leaf;
node->next = NULL;
for (int i = 0; i <= MAX_KEYS; i++) {
node->children[i] = NULL;
}
return node;
}
struct BPlusNode *findLeaf(struct BPlusNode *root, int key) {
struct BPlusNode *cur = root;
while (!cur->leaf) {
int i = 0;
while (i < cur->num_keys && key >= cur->keys[i]) {
i++;
}
cur = cur->children[i];
}
return cur;
}
void insertIntoLeaf(struct BPlusNode *leaf, int key) {
int i;
for (i = leaf->num_keys - 1; i >= 0 && leaf->keys[i] > key; i--) {
leaf->keys[i + 1] = leaf->keys[i];
}
leaf->keys[i + 1] = key;
leaf->num_keys++;
}
struct BPlusNode *insert(struct BPlusNode *root, int key) {
if (root == NULL) {
root = createNode(1);
root->keys[0] = key;
root->num_keys = 1;
return root;
}
struct BPlusNode *leaf = findLeaf(root, key);
insertIntoLeaf(leaf, key);
if (leaf->num_keys == MAX_KEYS) {
struct BPlusNode *newLeaf = createNode(1);
int mid = MAX_KEYS / 2;
for (int i = mid, j = 0; i < MAX_KEYS; i++, j++) {
newLeaf->keys[j] = leaf->keys[i];
}
newLeaf->num_keys = MAX_KEYS - mid;
leaf->num_keys = mid;
newLeaf->next = leaf->next;
leaf->next = newLeaf;
if (leaf == root) {
struct BPlusNode *newRoot = createNode(0);
newRoot->keys[0] = newLeaf->keys[0];
newRoot->children[0] = leaf;
newRoot->children[1] = newLeaf;
newRoot->num_keys = 1;
return newRoot;
}
}
return root;
}
void traverse(struct BPlusNode *root) {
if (root == NULL) {
printf("Tree is empty.\n");
return;
}
struct BPlusNode *cur = root;
while (!cur->leaf) {
cur = cur->children[0];
}
while (cur) {
for (int i = 0; i < cur->num_keys; i++) {
printf("%d ", cur->keys[i]);
}
cur = cur->next;
}
printf("\n");
}
int main() {
struct BPlusNode *root = NULL;
root = insert(root, 10);
root = insert(root, 20);
root = insert(root, 5);
root = insert(root, 6);
root = insert(root, 12);
root = insert(root, 30);
root = insert(root, 7);
root = insert(root, 17);
printf("B+ Tree traversal:\n");
traverse(root);

return 0;
}
#B-
#include <stdio.h>
#include <stdlib.h>

#define MAX_KEYS 3
#define MIN_KEYS (MAX_KEYS / 2)
#define MAX_CHILDREN (MAX_KEYS + 1)
struct BTreeNode {
int keys[MAX_KEYS];
struct BTreeNode *children[MAX_CHILDREN];
int num_keys;
int leaf;
};
struct BTreeNode *createNode(int leaf) {
struct BTreeNode *node = (struct BTreeNode *)malloc(sizeof(struct BTreeNode));
node->num_keys = 0;
node->leaf = leaf;
for (int i = 0; i <= MAX_KEYS; i++) {
node->children[i] = NULL;
}
return node;
}
void traverse(struct BTreeNode *root) {
if (root == NULL) return;
int i;
for (i = 0; i < root->num_keys; i++) {
if (!root->leaf) {
traverse(root->children[i]);
}
printf("%d ", root->keys[i]);
}
if (!root->leaf) {
traverse(root->children[i]);
}
}
struct BTreeNode *findChild(struct BTreeNode *root, int key) {
int i = 0;
while (i < root->num_keys && key > root->keys[i]) {
i++;
}
return root->children[i];
}
void splitChild(struct BTreeNode *parent, int index, struct BTreeNode *child) {
struct BTreeNode *newNode = createNode(child->leaf);
int mid = MAX_KEYS / 2;
int median = child->keys[mid];
for (int i = mid + 1, j = 0; i < MAX_KEYS; i++, j++) {
newNode->keys[j] = child->keys[i];
}
newNode->num_keys = MAX_KEYS - mid - 1;
child->num_keys = mid;
if (!child->leaf) {
for (int i = mid + 1, j = 0; i <= MAX_KEYS; i++, j++) {
newNode->children[j] = child->children[i];
}
}
for (int i = parent->num_keys; i > index; i--) {
parent->children[i + 1] = parent->children[i];
}
parent->children[index + 1] = newNode;
for (int i = parent->num_keys - 1; i >= index; i--) {
parent->keys[i + 1] = parent->keys[i];
}
parent->keys[index] = median;
parent->num_keys++;
}
void insertNonFull(struct BTreeNode *node, int key) {
int i = node->num_keys - 1;
if (node->leaf) {
while (i >= 0 && node->keys[i] > key) {
node->keys[i + 1] = node->keys[i];
i--;
}
node->keys[i + 1] = key;
node->num_keys++;
} else {
while (i >= 0 && node->keys[i] > key) {
i--;
}
i++;
if (node->children[i]->num_keys == MAX_KEYS) {
splitChild(node, i, node->children[i]);
if (key > node->keys[i]) {
i++;
}
}
insertNonFull(node->children[i], key);
}
}
struct BTreeNode *insert(struct BTreeNode *root, int key) {
if (root == NULL) {
root = createNode(1);
root->keys[0] = key;
root->num_keys = 1;
return root;
}
if (root->num_keys == MAX_KEYS) {
struct BTreeNode *newRoot = createNode(0);
newRoot->children[0] = root;
splitChild(newRoot, 0, root);
root = newRoot;
}

insertNonFull(root, key);
return root;
}
int main() {
struct BTreeNode *root = NULL;
root = insert(root, 10);
root = insert(root, 20);
root = insert(root, 5);
root = insert(root, 6);
root = insert(root, 12);
root = insert(root, 30);
root = insert(root, 7);
root = insert(root, 17);
printf("B- Tree traversal:\n");
traverse(root);
printf("\n");

return 0;
}
#AVL
#include <stdio.h>
#include <stdlib.h>
struct Node {
int data;
struct Node *left;
struct Node *right;
int height;
};

int max(int a, int b) {

return (a > b) ? a : b;
}

int height(struct Node *N) {

if (N == NULL)
return 0;
return N->height;
}

int getBalance(struct Node *N) {

if (N == NULL)
return 0;
return height(N->left) - height(N->right);
}

struct Node* newNode(int data) {

struct Node* node = (struct Node*)malloc(sizeof(struct Node));
node->data = data;
node->left = NULL;
node->right = NULL;
node->height = 1;
return node;
}

struct Node* rightRotate(struct Node *y) {

struct Node *x = y->left;
struct Node *T2 = x->right;

x->right = y;
y->left = T2;

y->height = max(height(y->left), height(y->right)) + 1;

x->height = max(height(x->left), height(x->right)) + 1;

return x;
}

struct Node* leftRotate(struct Node *x) {

struct Node *y = x->right;
struct Node *T2 = y->left;

y->left = x;
x->right = T2;

x->height = max(height(x->left), height(x->right)) + 1;

y->height = max(height(y->left), height(y->right)) + 1;

return y;
}

struct Node* insert(struct Node* node, int data) {

if (node == NULL)
return newNode(data);

if (data < node->data)

node->left = insert(node->left, data);
else if (data > node->data)
node->right = insert(node->right, data);
else
return node;

node->height = 1 + max(height(node->left), height(node->right));

int balance = getBalance(node);

if (balance > 1 && data < node->left->data)

return rightRotate(node);

if (balance < -1 && data > node->right->data)

return leftRotate(node);

if (balance > 1 && data > node->left->data) {

node->left = leftRotate(node->left);
return rightRotate(node);
}

if (balance < -1 && data < node->right->data) {

node->right = rightRotate(node->right);
return leftRotate(node);
}

return node;
}

struct Node* minValueNode(struct Node* node) {

struct Node* current = node;

while (current->left != NULL)

current = current->left;

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);

else if (data > root->data)

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

else {
if ((root->left == NULL) || (root->right == NULL)) {
struct Node *temp = root->left ? root->left : root->right;
if (temp == NULL) {
temp = root;
root = NULL;
} else
*root = *temp;
free(temp);
} else {
struct Node* temp = minValueNode(root->right);
root->data = temp->data;
root->right = deleteNode(root->right, temp->data);
}
}

if (root == NULL)
return root;

root->height = 1 + max(height(root->left), height(root->right));

int balance = getBalance(root);

if (balance > 1 && getBalance(root->left) >= 0)

return rightRotate(root);

if (balance > 1 && getBalance(root->left) < 0) {

root->left = leftRotate(root->left);
return rightRotate(root);
}

if (balance < -1 && getBalance(root->right) <= 0)

return leftRotate(root);

if (balance < -1 && getBalance(root->right) > 0) {

root->right = rightRotate(root->right);
return leftRotate(root);
}

return root;
}
void preorder(struct Node *root) {
if (root != NULL) {
printf("%d ", root->data);
preorder(root->left);
preorder(root->right);
}
}
void inorder(struct Node *root) {
if (root != NULL) {
inorder(root->left);
printf("%d ", root->data);
inorder(root->right);
}
}
void postorder(struct Node* root){
if(root == NULL){
return;
}
postorder(root->left);
postorder(root->right);
printf("%d ",root->data);
}
int main() {
struct Node *root = NULL;
root = insert(root, 4);
root = insert(root, 5);
root = insert(root, 6);
root = insert(root, 7);
root = insert(root, 8);
root = insert(root, 9);

printf("Postorder traversal of the constructed AVL tree: \n");

postorder(root);
printf("\n\n");

printf("Preorder traversal after deletion: \n");

preorder(root);
printf("\n\n");

printf("Inorder traversal of the constructed AVL tree: \n");

inorder(root);
printf("\n\n");

printf("Delete 5 from the tree.\n");

root = deleteNode(root, 5);

printf("Postorder traversal of the constructed AVL tree: \n");

postorder(root);
printf("\n\n");

printf("Inorder traversal of the constructed AVL tree: \n");

inorder(root);
printf("\n\n");

return 0;
}
#Splay Tree
#include <stdio.h>
#include <stdlib.h>
struct SplayNode {
int data;
struct SplayNode *left, *right;
};
struct SplayNode* createNode(int data) {
struct SplayNode* node = (struct SplayNode*)malloc(sizeof(struct SplayNode));
node->data = data;
node->left = node->right = NULL;
return node;
}
struct SplayNode* rightRotate(struct SplayNode* x) {
struct SplayNode* y = x->left;
x->left = y->right;
y->right = x;
return y;
}
struct SplayNode* leftRotate(struct SplayNode* x) {
struct SplayNode* y = x->right;
x->right = y->left;
y->left = x;
return y;
}
struct SplayNode* splay(struct SplayNode* root, int key) {
if (root == NULL || root->data == key)
return root;
if (key < root->data) {
if (root->left == NULL)
return root;
if (key < root->left->data) {
root->left->left = splay(root->left->left, key);
root = rightRotate(root);
}
else if (key > root->left->data) {
root->left->right = splay(root->left->right, key);
if (root->left->right != NULL)
root->left = leftRotate(root->left);
}
return (root->left == NULL) ? root : rightRotate(root);
}
else {
if (root->right == NULL)
return root;
if (key < root->right->data) {
root->right->left = splay(root->right->left, key);
if (root->right->left != NULL)
root->right = rightRotate(root->right);
}
else if (key > root->right->data) {
root->right->right = splay(root->right->right, key);
root = leftRotate(root);
}
return (root->right == NULL) ? root : leftRotate(root);
}
}
struct SplayNode* insert(struct SplayNode* root, int key) {
if (root == NULL)
return createNode(key);

root = splay(root, key);

if (root->data == key)
return root;

struct SplayNode* newNode = createNode(key);

if (key < root->data) {

newNode->right = root;
newNode->left = root->left;
root->left = NULL;
} else {
newNode->left = root;
newNode->right = root->right;
root->right = NULL;
}
return newNode;
}
void inorder(struct SplayNode* root) {
if (root != NULL) {
inorder(root->left);
printf("%d ", root->data);
inorder(root->right);
}
}
int main() {
struct SplayNode* root = NULL;
root = insert(root, 100);
root = insert(root, 50);
root = insert(root, 200);
root = insert(root, 40);
root = insert(root, 30);
root = insert(root, 20);
printf("Splay Tree in-order traversal:\n");
inorder(root);
printf("\n");

return 0;
}
#Sequential search
#include <stdio.h>
int sequentialSearch(int arr[], int size, int key) {
for (int i = 0; i < size; i++) {
if (arr[i] == key) {
return i;
}
}
return -1;
}
int main() {
int arr[] = {10, 20, 30, 40, 50};
int size = sizeof(arr) / sizeof(arr[0]);
int key;
printf("Enter the element to search: ");
scanf("%d", &key);
int result = sequentialSearch(arr, size, key);
if (result != -1) {
printf("Element found at index %d\n", result);
} else {
printf("Element not found\n");
}
return 0;
}
#Binary Search
#include <stdio.h>
int binarySearch(int arr[], int left, int right, int key) {
while (left <= right) {
int mid = left + (right - left) / 2;
if (arr[mid] == key)
return mid;
if (arr[mid] < key)
left = mid + 1;
else
right = mid - 1;
}
return -1;
}
int main() {
int arr[] = {10, 20, 30, 40, 50};
int size = sizeof(arr) / sizeof(arr[0]);
int key;
printf("Enter the element to search: ");
scanf("%d", &key);
int result = binarySearch(arr, 0, size - 1, key);
if (result != -1) {
printf("Element found at index %d\n", result);
} else {
printf("Element not found\n");
}
return 0;
}
#Breadth First Search
#include <stdio.h>
#include <stdlib.h>
#define MAX 100
typedef struct {
int items[MAX];
int front, rear;
} Queue;
void initQueue(Queue *q) {
q->front = -1;
q->rear = -1;
}
int isEmpty(Queue *q) {
return q->front == -1;
}
void enqueue(Queue *q, int value) {
if (q->rear == MAX - 1) {
printf("Queue is full!\n");
return;
}
if (q->front == -1) q->front = 0;
q->items[++(q->rear)] = value;
}
int dequeue(Queue *q) {
if (isEmpty(q)) {
printf("Queue is empty!\n");
return -1;
}
int item = q->items[q->front];
if (q->front >= q->rear) {
q->front = -1;
q->rear = -1;
} else {
q->front++;
}
return item;
}
void BFS(int graph[MAX][MAX], int startVertex, int vertices) {
int visited[MAX] = {0};
Queue q;
initQueue(&q);
printf("BFS Traversal: ");
visited[startVertex] = 1;
enqueue(&q, startVertex);
while (!isEmpty(&q)) {
int currentVertex = dequeue(&q);
printf("%d ", currentVertex);
for (int i = 0; i < vertices; i++) {
if (graph[currentVertex][i] == 1 && !visited[i]) {
visited[i] = 1;
enqueue(&q, i);
}
}
}
printf("\n");
}
int main() {
int vertices = 5;
int graph[MAX][MAX] = {
{0, 1, 1, 0, 0},
{1, 0, 0, 1, 1},
{1, 0, 0, 1, 0},
{0, 1, 1, 0, 1},
{0, 1, 0, 1, 0}
};
int startVertex;
printf("Enter the starting vertex: ");
scanf("%d", &startVertex);
BFS(graph, startVertex, vertices);
return 0;
}
# Depth First Search
#include <stdio.h>
#define MAX 100
void DFS(int graph[MAX][MAX], int vertex, int visited[], int vertices) {
printf("%d ", vertex);
visited[vertex] = 1;
for (int i = 0; i < vertices; i++) {
if (graph[vertex][i] == 1 && !visited[i]) {
DFS(graph, i, visited, vertices);
}
}
}
int main() {
int vertices = 5;
int graph[MAX][MAX] = {
{0, 1, 1, 0, 0},
{1, 0, 0, 1, 1},
{1, 0, 0, 1, 0},
{0, 1, 1, 0, 1},
{0, 1, 0, 1, 0}
};
int visited[MAX] = {0};
int startVertex;
printf("Enter the starting vertex: ");
scanf("%d", &startVertex);
printf("DFS Traversal: ");
DFS(graph, startVertex, visited, vertices);
printf("\n");
return 0;
}
#Insertion Sort
#include <stdio.h>
void insertionSort(int arr[], int size) {
for (int i = 1; i < size; i++) {
int key = arr[i];
int j = i - 1;
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = key;
}
}
void printArray(int arr[], int size) {
for (int i = 0; i < size; i++) {
printf("%d ", arr[i]);
}
printf("\n");
}
int main() {
int arr[] = {64, 25, 12, 22, 11};
int size = sizeof(arr) / sizeof(arr[0]);
printf("Original array: ");
printArray(arr, size);
insertionSort(arr, size);
printf("Sorted array: ");
printArray(arr, size);
return 0;
}
#Selection Sort
#include <stdio.h>
void selectionSort(int arr[], int n) {
int i, j, minIndex, temp;
for (i = 0; i < n - 1; i++) {
minIndex = i;
for (j = i + 1; j < n; j++) {
if (arr[j] < arr[minIndex]) {
minIndex = j;
}
}
if (minIndex != i) {
temp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = temp;
}
}
}
void printArray(int arr[], int n) {
for (int i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
printf("\n");
}
int main() {
int arr[] = {64, 25, 12, 22, 11};
int n = sizeof(arr) / sizeof(arr[0]);
printf("Original array: ");
printArray(arr, n);
selectionSort(arr, n);
printf("Sorted array: ");
printArray(arr, n);
return 0;
}
#Shell Sort
#include <stdio.h>
void shellSort(int arr[], int n) {
for (int gap = n / 2; gap > 0; gap /= 2) {
for (int i = gap; i < n; i++) {
int temp = arr[i];
int j;
for (j = i; j >= gap && arr[j - gap] > temp; j -= gap) {
arr[j] = arr[j - gap];
}
arr[j] = temp;
}
}
}
void printArray(int arr[], int n) {
for (int i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
printf("\n");
}
int main() {
int arr[] = {12, 34, 54, 2, 3};
int n = sizeof(arr) / sizeof(arr[0]);
printf("Original array: ");
printArray(arr, n);
shellSort(arr, n);
printf("Sorted array: ");
printArray(arr, n);
return 0;
}
# Merge Sort
#include <stdio.h>
void merge(int arr[], int left, int mid, int right) {
int n1 = mid - left + 1;
int n2 = right - mid;
int L[n1], R[n2];
for (int i = 0; i < n1; i++)
L[i] = arr[left + i];
for (int j = 0; j < n2; j++)
R[j] = arr[mid + 1 + j];
int i = 0, j = 0, k = left;
while (i < n1 && j < n2) {
if (L[i] <= R[j]) {
arr[k] = L[i];
i++;
} else {
arr[k] = R[j];
j++;
}
k++;
}
while (i < n1) {
arr[k] = L[i];
i++;
k++;
}
while (j < n2) {
arr[k] = R[j];
j++;
k++;
}
}
void mergeSort(int arr[], int left, int right) {
if (left < right) {
int mid = left + (right - left) / 2;
mergeSort(arr, left, mid);
mergeSort(arr, mid + 1, right);
merge(arr, left, mid, right);
}
}
void printArray(int arr[], int size) {
for (int i = 0; i < size; i++)
printf("%d ", arr[i]);
printf("\n");
}
int main() {
int arr[] = {12, 11, 13, 5, 6, 7};
int n = sizeof(arr) / sizeof(arr[0]);
printf("Original array: ");
printArray(arr, n);
mergeSort(arr, 0, n - 1);
printf("Sorted array: ");
printArray(arr, n);
return 0;
}
#Quick Sort
#include <stdio.h>
void swap(int *a, int *b) {
int temp = *a;
*a = *b;
*b = temp;
}
int partition(int arr[], int low, int high) {
int pivot = arr[high];
int i = low - 1;

for (int j = low; j < high; j++) {

if (arr[j] < pivot) {
i++;
swap(&arr[i], &arr[j]);
}
}
swap(&arr[i + 1], &arr[high]);
return (i + 1);
}
void quickSort(int arr[], int low, int high) {
if (low < high) {
int pi = partition(arr, low, high);
quickSort(arr, low, pi - 1);
quickSort(arr, pi + 1, high);
}
}
void printArray(int arr[], int size) {
for (int i = 0; i < size; i++)
printf("%d ", arr[i]);
printf("\n");
}
int main() {
int arr[] = {10, 7, 8, 9, 1, 5};
int n = sizeof(arr) / sizeof(arr[0]);
printf("Original array: ");
printArray(arr, n);
quickSort(arr, 0, n - 1);
printf("Sorted array: ");
printArray(arr, n);
return 0;
}
#Heap Sort
#include <stdio.h>
void swap(int *a, int *b) {
int temp = *a;
*a = *b;
*b = temp;
}
void heapify(int arr[], int n, int i) {
int largest = i;
int left = 2 * i + 1;
int right = 2 * i + 2;
if (left < n && arr[left] > arr[largest])
largest = left;
if (right < n && arr[right] > arr[largest])
largest = right;
if (largest != i) {
swap(&arr[i], &arr[largest]);
heapify(arr, n, largest);
}
}
void heapSort(int arr[], int n) {
for (int i = n / 2 - 1; i >= 0; i--)
heapify(arr, n, i);
for (int i = n - 1; i > 0; i--) {
swap(&arr[0], &arr[i]);
heapify(arr, i, 0);
}
}
void printArray(int arr[], int size) {
for (int i = 0; i < size; i++)
printf("%d ", arr[i]);
printf("\n");
}
int main() {
int arr[] = {12, 11, 13, 5, 6, 7};
int n = sizeof(arr) / sizeof(arr[0]);
printf("Original array: ");
printArray(arr, n);
heapSort(arr, n);
printf("Sorted array: ");
printArray(arr, n);
return 0;
}
# krushal Algo.
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
class Edge {
public:
int src, dest, weight;
};
class Graph {
public:
int V, E;
vector<Edge> edges;
Graph(int V, int E) {
this->V = V;
this->E = E;
}
void addEdge(int src, int dest, int weight) {
edges.push_back({src, dest, weight});
}
static bool compare(Edge a, Edge b) {
return a.weight < b.weight;
}
int findParent(vector<int> &parent, int i) {
if (parent[i] == i) return i;
return findParent(parent, parent[i]);
}
void kruskalMST() {
sort(edges.begin(), edges.end(), compare);
vector<int> parent(V);
for (int i = 0; i < V; i++)
parent[i] = i;
int cost = 0;
for (auto &edge : edges) {
int x = findParent(parent, edge.src);
int y = findParent(parent, edge.dest);
if (x != y) {
cout << edge.src << " - " << edge.dest << " : " << edge.weight << endl;
cost += edge.weight;
parent[x] = y;
}
}
cout << "Total cost(MST): " << cost << endl;
}
};
int main() {
Graph g(4, 5);
g.addEdge(0, 2, 10);
g.addEdge(0, 3, 6);
g.addEdge(0, 4, 5);
g.addEdge(1, 5, 15);
g.addEdge(2, 4, 4);
cout<<"MST: ";
g.kruskalMST();
return 0;
}
#Prim’s Algo.
#include <iostream>
#include <climits>
using namespace std;
#define V 5
int minKey(int key[], bool mstSet[]) {
int min = INT_MAX, minIndex;
for (int v = 0; v < V; v++)
if (!mstSet[v] && key[v] < min)
min = key[v], minIndex = v;
return minIndex;
}
void primMST(int graph[V][V]) {
int parent[V], key[V];
bool mstSet[V];
fill(key, key + V, INT_MAX);
fill(mstSet, mstSet + V, false);
key[0] = 0;
parent[0] = -1;
for (int count = 0; count < V - 1; count++) {
int u = minKey(key, mstSet);
mstSet[u] = true;
for (int v = 0; v < V; v++)
if (graph[u][v] && !mstSet[v] && graph[u][v] < key[v])
parent[v] = u, key[v] = graph[u][v];
}
for (int i = 1; i < V; i++)
cout << parent[i] << " - " << i << " : " << graph[i][parent[i]] << endl;
}
int main() {
int graph[V][V] = {
{0, 1, 2, 3, 0},
{2, 3, 4, 8, 7},
{0, 3, 0, 0, 7},
{7, 9, 2, 0, 9},
{0, 5, 7, 6, 0}
};
cout<<"MST: ";
primMST(graph);
return 0;
}
#Selection Sort
#include <iostream>
using namespace std;
void selectionSort(int arr[], int n) {
for (int i = 0; i < n - 1; i++) {
int minIdx = i;
for (int j = i + 1; j < n; j++) {
if (arr[j] < arr[minIdx])
minIdx = j;
}
swap(arr[minIdx], arr[i]);
}
}
int main() {
int arr[] = {16,25,14,19,15,28};
int n = sizeof(arr) / sizeof(arr[0]);
selectionSort(arr, n);
cout<<"Selection sort: ";
for (int i = 0; i < n; i++)
cout << arr[i] << " ";
return 0;
}
# TBT
#include <stdio.h>
#include <stdlib.h>
struct TBTNode {
int data;
struct TBTNode *left, *right;
int lthread, rthread;
};
struct TBTNode* createTBTNode(int data) {
struct TBTNode* newNode = (struct TBTNode*)malloc(sizeof(struct TBTNode));
newNode->data = data;
newNode->left = newNode->right = NULL;
newNode->lthread = 1;
newNode->rthread = 1;
return newNode;
}
struct TBTNode* insertTBT(struct TBTNode* root, int data) {
struct TBTNode* newNode = createTBTNode(data);
if (root == NULL) return newNode;
struct TBTNode* cur = root;
struct TBTNode* parent = NULL;
while (cur != NULL) {
parent = cur;
if (data < cur->data) {
if (cur->lthread == 0) {
cur = cur->left;
} else {
break;
}
} else {
if (cur->rthread == 0) {
cur = cur->right;
} else {
break;
}
}
}

if (data < parent->data) {

newNode->left = parent->left;
newNode->right = parent;
parent->lthread = 0;
parent->left = newNode;
} else {
newNode->right = parent->right;
newNode->left = parent;
parent->rthread = 0;
parent->right = newNode;
}

return root;
}
struct TBTNode* leftmost(struct TBTNode* root) {
while (root != NULL && root->lthread == 0)
root = root->left;
return root;
}
void inorderTBT(struct TBTNode* root) {
struct TBTNode* cur = leftmost(root);
while (cur != NULL) {
printf("%d ", cur->data);
if (cur->rthread == 1) {
cur = cur->right;
} else {
cur = leftmost(cur->right);
}
}
}
int main() {
struct TBTNode* root = NULL;
root = insertTBT(root, 50);
root = insertTBT(root, 30);
root = insertTBT(root, 70);
root = insertTBT(root, 20);
root = insertTBT(root, 40);
root = insertTBT(root, 60);
root = insertTBT(root, 80);
printf("Inorder Traversal of Threaded Binary Tree:\n");
inorderTBT(root);
return 0;
}
#Dijkstra Algo
#include <iostream>
#include <climits>
using namespace std;
#define V 5
int minDistance(int dist[], bool visited[]) {
int min = INT_MAX, minIndex;
for (int v = 0; v < V; v++)
if (!visited[v] && dist[v] <= min)
min = dist[v], minIndex = v;
return minIndex;
}
void dijkstra(int graph[V][V], int src) {
int dist[V];
bool visited[V];
for (int i = 0; i < V; i++)
dist[i] = INT_MAX, visited[i] = false;
dist[src] = 0;
for (int count = 0; count < V - 1; count++) {
int u = minDistance(dist, visited);
visited[u] = true;
for (int v = 0; v < V; v++)
if (!visited[v] && graph[u][v] && dist[u] + graph[u][v] < dist[v])
dist[v] = dist[u] + graph[u][v];
}
for (int i = 0; i < V; i++)
cout << "Vertex " << i << ": Distance " << dist[i] << endl;
}
int main() {
int graph[V][V] = {{0, 10, 0, 30, 100},
{10, 0, 50, 0, 0},
{0, 50, 0, 20, 10},
{30, 0, 20, 0, 60},
{100, 0, 10, 60, 0}};
cout<<"Dijkstra: ";
dijkstra(graph, 0);
return 0;
}
#Tower of Hanoi
#include <stdio.h>
void towerOfHanoi(int n, char source, char auxiliary, char destination) {
if (n == 1) {
printf("Move disk 1 from %c to %c\n", source, destination);
return;
}
towerOfHanoi(n - 1, source, destination, auxiliary);
printf("Move disk %d from %c to %c\n", n, source, destination);
towerOfHanoi(n - 1, auxiliary, source, destination);
}
int main() {
int n;
printf("Enter the number of disks: ");
scanf("%d", &n);
printf("Solution for %d disks:\n", n);
towerOfHanoi(n, 'A', 'B', 'C');
return 0;
}
#Doubly Linked List
#include <stdio.h>
#include <stdlib.h>

// Structure for a node

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

// Function to create a new node

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;
}

// Insert at the beginning

void insertAtBeginning(struct Node** head, int data) {
struct Node* newNode = createNode(data);
newNode->next = *head;

if (*head != NULL)
(*head)->prev = newNode;

*head = newNode;
}

// Insert at the end

void insertAtEnd(struct Node** head, int data) {
struct Node* newNode = createNode(data);
struct Node* temp = *head;

if (*head == NULL) {
*head = newNode;
return;
}

while (temp->next != NULL)

temp = temp->next;

temp->next = newNode;
newNode->prev = temp;
}
// Insert after a given node (by value)
void insertAfter(struct Node* head, int afterValue, int data) {
struct Node* temp = head;

while (temp != NULL && temp->data != afterValue)

temp = temp->next;

if (temp == NULL) {
printf("Node with value %d not found.\n", afterValue);
return;
}

struct Node* newNode = createNode(data);

newNode->next = temp->next;
newNode->prev = temp;

if (temp->next != NULL)
temp->next->prev = newNode;

temp->next = newNode;
}

// Delete from beginning

void deleteFromBeginning(struct Node** head) {
if (*head == NULL) {
printf("List is empty.\n");
return;
}

struct Node* temp = *head;

*head = temp->next;

if (*head != NULL)
(*head)->prev = NULL;

free(temp);
}

// Delete from end

void deleteFromEnd(struct Node** head) {
if (*head == NULL) {
printf("List is empty.\n");
return;
}

struct Node* temp = *head;

while (temp->next != NULL)

temp = temp->next;

if (temp->prev != NULL)
temp->prev->next = NULL;
else
*head = NULL;

free(temp);
}

// Delete a node by value

void deleteNode(struct Node** head, int value) {
struct Node* temp = *head;

while (temp != NULL && temp->data != value)

temp = temp->next;

if (temp == NULL) {
printf("Node with value %d not found.\n", value);
return;
}

if (temp->prev != NULL)
temp->prev->next = temp->next;
else
*head = temp->next;

if (temp->next != NULL)
temp->next->prev = temp->prev;

free(temp);
}

// Display the list forward

void displayForward(struct Node* head) {
struct Node* temp = head;
printf("List (forward): ");
while (temp != NULL) {
printf("%d ", temp->data);
temp = temp->next;
}
printf("\n");
}

// Display the list in reverse

void displayReverse(struct Node* head) {
struct Node* temp = head;

if (temp == NULL) {
printf("List is empty.\n");
return;
}

// Go to the last node

while (temp->next != NULL)
temp = temp->next;

printf("List (reverse): ");

while (temp != NULL) {
printf("%d ", temp->data);
temp = temp->prev;
}
printf("\n");
}

// Main function for testing

int main() {
struct Node* head = NULL;

insertAtEnd(&head, 10);
insertAtEnd(&head, 20);
insertAtBeginning(&head, 5);
insertAfter(head, 10, 15);
displayForward(head);
displayReverse(head);

deleteFromBeginning(&head);
deleteFromEnd(&head);
deleteNode(&head, 15);
displayForward(head);
displayReverse(head);

return 0;
}
#Circular Linked List
#include <stdio.h>
#include <stdlib.h>

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

// Create new node

struct Node* createNode(int data) {
struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->data = data;
newNode->next = NULL;
return newNode;
}

// Insert at beginning
void insertAtBeginning(struct Node** head, int data) {
struct Node* newNode = createNode(data);
if (*head == NULL) {
newNode->next = newNode;
*head = newNode;
return;
}
struct Node* temp = *head;
while (temp->next != *head)
temp = temp->next;

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

// Insert at end
void insertAtEnd(struct Node** head, int data) {
struct Node* newNode = createNode(data);
if (*head == NULL) {
newNode->next = newNode;
*head = newNode;
return;
}

struct Node* temp = *head;

while (temp->next != *head)
temp = temp->next;

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

// Insert at specific position

void insertAtPosition(struct Node** head, int data, int pos) {
if (pos <= 0) {
printf("Invalid position.\n");
return;
}

if (pos == 1) {
insertAtBeginning(head, data);
return;
}

struct Node* newNode = createNode(data);

struct Node* temp = *head;
for (int i = 1; i < pos - 1; i++) {
if (temp->next == *head) {
printf("Position out of range.\n");
return;
}
temp = temp->next;
}

newNode->next = temp->next;
temp->next = newNode;
}

// Delete from beginning

void deleteFromBeginning(struct Node** head) {
if (*head == NULL) {
printf("List is empty.\n");
return;
}

struct Node* temp = *head;

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

struct Node* last = *head;

while (last->next != *head)
last = last->next;

last->next = temp->next;
*head = temp->next;
free(temp);
}

// Delete from end

void deleteFromEnd(struct Node** head) {
if (*head == NULL) {
printf("List is empty.\n");
return;
}

struct Node* temp = *head;

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

struct Node* prev = NULL;

while (temp->next != *head) {
prev = temp;
temp = temp->next;
}

prev->next = *head;
free(temp);
}

// Delete from position

void deleteFromPosition(struct Node** head, int pos) {
if (*head == NULL || pos <= 0) {
printf("Invalid position or empty list.\n");
return;
}

if (pos == 1) {
deleteFromBeginning(head);
return;
}

struct Node* temp = *head;

struct Node* prev = NULL;

for (int i = 1; i < pos; i++) {

prev = temp;
temp = temp->next;
if (temp == *head) {
printf("Position out of range.\n");
return;
}
}

prev->next = temp->next;
free(temp);
}

// Delete by value
void deleteByValue(struct Node** head, int value) {
if (*head == NULL) {
printf("List is empty.\n");
return;
}

struct Node* curr = *head;

struct Node* prev = NULL;

// If head is to be deleted
if (curr->data == value) {
deleteFromBeginning(head);
return;
}

do {
prev = curr;
curr = curr->next;
if (curr->data == value) {
prev->next = curr->next;
free(curr);
return;
}
} while (curr != *head);

printf("Value %d not found in the list.\n", value);

}

// Display
void display(struct Node* head) {
if (head == NULL) {
printf("List is empty.\n");
return;
}

struct Node* temp = head;

printf("Circular Linked List: ");
do {
printf("%d ", temp->data);
temp = temp->next;
} while (temp != head);
printf("\n");
}

// Main function
int main() {
struct Node* head = NULL;

insertAtEnd(&head, 10);
insertAtEnd(&head, 20);
insertAtBeginning(&head, 5);
insertAtEnd(&head, 30);
insertAtPosition(&head, 15, 3);
display(head);

deleteFromBeginning(&head);
display(head);

deleteFromEnd(&head);
display(head);

deleteFromPosition(&head, 2);
display(head);

deleteByValue(&head, 15);
display(head);

deleteByValue(&head, 100); // Should show "not found"

return 0;
}