For Your Reference - https://chatgpt.

com/share/6735d8a9-0298-800e-9a84-36f951caac21

Linked List Operations

1. Create and Display Linked List (Singly or Doubly) (4 Marks)

o Explanation:

▪ Create Function: For each element, create a new node and link it to the
previous node.

▪ Display Function: Traverse the list from the head node and print each node’s
data until reaching NULL.

o Code:

#include <stdio.h>

#include <stdlib.h>

struct Node {

int data;

struct Node* next;

};

struct Node* createNode(int data) {

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

newNode->data = data;

newNode->next = NULL;

return newNode;

void displayList(struct Node* head) {

struct Node* current = head;

while (current != NULL) {

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

current = current->next;

printf("NULL\n");

int main() {

struct Node* head = createNode(1);

 head->next = createNode(2);

head->next->next = createNode(3);

displayList(head);

return 0;

2. Delete the First Node in a Singly Linked List (4 Marks)

o Explanation:

▪ Update head to point to the second node.

▪ Free the original head node.

o Code:

void deleteFirstNode(struct Node** head) {

if (*head == NULL) return;

struct Node* temp = *head;

*head = (*head)->next;

free(temp);

3. Reverse a String Using Stack (4 Marks)

o Explanation:

▪ Push each character of the string onto the stack.

▪ Pop each character from the stack to reverse the string.

o Code:

#include <stdio.h>

#include <string.h>

#define MAX 100

void reverseString(char* str) {

int len = strlen(str);

char stack[MAX];

int top = -1;

// Push characters onto stack

for (int i = 0; i < len; i++) {

stack[++top] = str[i];
 }

// Pop characters to reverse

for (int i = 0; i < len; i++) {

str[i] = stack[top--];

int main() {

char str[] = "hello";

reverseString(str);

printf("Reversed string: %s\n", str);

return 0;

4. Traverse and Display a Linked List in Reverse Order (4 Marks)

o Explanation:

▪ Traverse to the end and print nodes in reverse using recursion.

o Code:

void displayReverse(struct Node* head) {

if (head == NULL) return;

displayReverse(head->next);

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

Stack Operations and Applications

1. Convert Infix to Postfix Expression (5 Marks)

o Explanation:

▪ Use a stack to hold operators.

▪ Follow operator precedence and associativity rules.

o Code:

#include <stdio.h>

#include <ctype.h>
#define MAX 100

char stack[MAX];

int top = -1;

void push(char c) { stack[++top] = c; }

char pop() { return stack[top--]; }

int precedence(char c) { return (c == '+' || c == '-') ? 1 : (c == '*' || c == '/') ? 2 : -1; }

void infixToPostfix(char* expr) {

for (int i = 0; expr[i] != '\0'; i++) {

if (isalnum(expr[i])) printf("%c", expr[i]);

else if (expr[i] == '(') push(expr[i]);

else if (expr[i] == ')') while (top != -1 && stack[top] != '(') printf("%c", pop()); pop();

else {

while (top != -1 && precedence(stack[top]) >= precedence(expr[i])) printf("%c", pop());

push(expr[i]);

while (top != -1) printf("%c", pop());

int main() {

char expr[] = "A+B*C-D";

infixToPostfix(expr);

return 0;

Sorting Algorithms

1. Insertion Sort (4 Marks)

o Explanation:

▪ Starts with the second element, inserting it into the correct position in the
sorted section.

o Code:
void insertionSort(int arr[], int n) {

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

int key = arr[i];

int j = i - 1;

while (j >= 0 && arr[j] > key) {

arr[j + 1] = arr[j];

j = j - 1;

arr[j + 1] = key;

2. Selection Sort (Quick Sort or Merge Sort) (4 Marks)

o Selection Sort Explanation:

▪ Repeatedly finds the minimum element and places it in the sorted portion.

o Code for Selection Sort:

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;

int temp = arr[minIdx];

arr[minIdx] = arr[i];

arr[i] = temp;

Tree and Graph Traversals

1. Binary Tree Traversal Functions (Inorder, Preorder, Postorder) (4 Marks)

o Explanation:

▪ Recursive functions to visit nodes in specific orders.

 o Code for Inorder, Preorder, and Postorder Traversals:

void inorder(struct Node* node) {

if (node == NULL) return;

inorder(node->left);

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

inorder(node->right);

void preorder(struct Node* node) {

if (node == NULL) return;

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

preorder(node->left);

preorder(node->right);

void postorder(struct Node* node) {

if (node == NULL) return;

postorder(node->left);

postorder(node->right);

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

2. Graph Traversals (BFS and DFS) (5 Marks)

o DFS Explanation:

▪ Depth-first search using recursion or a stack.

o BFS Explanation:

▪ Breadth-first search using a queue.

o Code for DFS:

void DFS(int vertex, int visited[], int graph[][MAX], int n) {

printf("%d ", vertex);

visited[vertex] = 1;

for (int i = 0; i < n; i++) if (graph[vertex][i] && !visited[i]) DFS(i, visited, graph, n);

}
Queue Operations

1. Insert Element in Circular or Static Queue (4 Marks)

o Explanation:

▪ Circular queue uses modulo operation for wrapping around.

o Code:

void enqueue(int queue[], int* front, int* rear, int item, int size) {

if ((*rear + 1) % size == *front) return; // Queue is full

*rear = (*rear + 1) % size;

queue[*rear] = item;

if (*front == -1) *front = 0; // Initialize front if empty

2. Double-Ended Queue (Dequeue) (4 Marks)

o Explanation:

▪ Allows insertions and deletions from both front and rear ends.

o Code (Operations Illustration):

void insertFront(int deque[], int* front, int* rear, int item, int size) { /* Implementation */ }

void insertRear(int deque[], int* front, int* rear, int item, int size) { /* Implementation */ }

void deleteFront(int deque[], int* front, int* rear, int size) { /* Implementation */ }

void deleteRear(int deque[], int* front, int* rear, int size) { /* Implementation */ }

Miscellaneous Data Structure Programs

1. Binary Search (4 Marks)

o Explanation:

▪ Binary search on sorted data using divide and conquer.

o Code:

int binarySearch(int arr[], int l, int r, int x) {

while (l <= r) {

int mid = l + (r - l) / 2;

if (arr[mid] == x) return mid;

else if (arr[mid] < x) l = mid + 1;

else r = mid - 1;
 }

return -1;

2. Polynomial Evaluation (5 Marks)

o Explanation:

▪ Evaluate polynomial by substituting values and summing up terms.

o Code:

int evaluatePolynomial(int coeff[], int exp[], int n, int x) {

int result = 0;

for (int i = 0; i < n; i++) result += coeff[i] * pow(x, exp[i]);

return result;