Selected Data Structure Programs

1. Write a program to search for an element in an array using binary and linear
search.

#include <stdio.h>

int linear_search(int arr[], int n, int target) {

for (int i = 0; i < n; i++) {
if (arr[i] == target) {
return i; // Element found, return index
}
}
return -1; // Element not found
}

int binary_search(int arr[], int n, int target) {

int low = 0, high = n - 1;
while (low <= high) {
int mid = (low + high) / 2;
if (arr[mid] == target) return mid;
else if (arr[mid] < target) low = mid + 1;
else high = mid - 1;
}
return -1;
}

int main() {
int arr[] = {2, 5, 8, 12, 16, 20, 24};
int n = sizeof(arr) / sizeof(arr[0]);
int target_linear = 12, target_binary = 16;

int linear_result = linear_search(arr, n, target_linear);

printf("Linear Search Result (Target %d): %d\n", target_linear, linear_result);

int binary_result = binary_search(arr, n, target_binary);

printf("Binary Search Result (Target %d): %d\n", target_binary, binary_result);

return 0;
}
Output:
Linear Search Result (Target 12): 3
Binary Search Result (Target 16): 4

2. Write a program to sort list of n numbers using Bubble Sort algorithms.

#include <stdio.h>

void bubble_sort(int arr[], int n) {

for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}

int main() {
int arr[] = {64, 34, 25, 12, 22, 11, 90};
int n = sizeof(arr) / sizeof(arr[0]);

bubble_sort(arr, n);

printf("Sorted array using Bubble Sort: ");

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

return 0;
}

Output:
Sorted array using Bubble Sort: 11 12 22 25 34 64 90

3. Perform the Insertion and Selection Sort on the input {75,8,1,16,48,3,7,0} and
display the output in descending order.

#include <stdio.h>
void insertion_sort_desc(int arr[], int n) {
for (int i = 1; i < n; i++) {
int key = arr[i], j = i - 1;
while (j >= 0 && arr[j] < key) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = key;
}
}

int main() {
int arr[] = {75, 8, 1, 16, 48, 3, 7, 0};
int n = sizeof(arr) / sizeof(arr[0]);

insertion_sort_desc(arr, n);

printf("Sorted array (Descending) using Insertion Sort: ");

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

return 0;
}

Output:
Sorted array (Descending) using Insertion Sort: 75 48 16 8 7 3 1 0

4. Write a program to insert the elements {61,16,8,27} into singly linked

list and delete 8,61,27 from the list. Display your list after each insertion
and deletion.

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

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

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

 struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->data = data;
newNode->next = *head;
*head = newNode;
}

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

struct Node* temp = *head, *prev = NULL;
if (temp != NULL && temp->data == key) {
*head = temp->next;
free(temp);
return;
}
while (temp != NULL && temp->data != key) {
prev = temp;
temp = temp->next;
}
if (temp == NULL) return;
prev->next = temp->next;
free(temp);
}

void display(struct Node* head) {

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

int main() {
struct Node* head = NULL;
insert(&head, 61);
insert(&head, 16);
insert(&head, 8);
insert(&head, 27);
display(head);

delete(&head, 8);
delete(&head, 61);
delete(&head, 27);
display(head);
 return 0;
}

Output:
8 -> 16 -> 27 -> 61 -> NULL
16 -> 27 -> NULL

5. Write a program to insert the elements {45, 34, 10, 63,3} into linear queue
and delete three elements from the list. Display your list after each insertion
and deletion.

#include <stdio.h>
#define SIZE 5

int queue[SIZE], front = -1, rear = -1;

void enqueue(int value) {

if (rear == SIZE - 1) printf("Queue is full!\n");
else {
if (front == -1) front = 0;
queue[++rear] = value;
printf("Enqueued: %d\n", value);
}
}

void dequeue() {
if (front == -1 || front > rear) printf("Queue is empty!\n");
else printf("Dequeued: %d\n", queue[front++]);
}

void display() {
if (front == -1 || front > rear) printf("Queue is empty!\n");
else {
for (int i = front; i <= rear; i++) printf("%d ", queue[i]);
printf("\n");
}
}

int main() {
enqueue(45);
enqueue(34);
enqueue(10);
 enqueue(63);
enqueue(3);
display();

dequeue();
dequeue();
dequeue();
display();

return 0;
}

Output:
Enqueued: 45, 34, 10, 63, 3
Dequeued: 45, 34, 10
Queue after deletion: 63, 3

6. Write a program to simulate the working of Circular queue using

array.

#include <stdio.h>
#define SIZE 5

int queue[SIZE];
int front = -1, rear = -1;

int isFull() {
return (rear + 1) % SIZE == front;
}

int isEmpty() {
return front == -1;
}

void enqueue(int value) {

if (isFull()) {
printf("Queue is Full!\n");
} else {
if (front == -1) front = 0; // First element
rear = (rear + 1) % SIZE;
 queue[rear] = value;
printf("Enqueued: %d\n", value);
}
}

void dequeue() {
if (isEmpty()) {
printf("Queue is Empty!\n");
} else {
printf("Dequeued: %d\n", queue[front]);
if (front == rear) {
front = rear = -1; // Reset queue after last element
} else {
front = (front + 1) % SIZE;
}
}
}

void display() {
if (isEmpty()) {
printf("Queue is Empty!\n");
} else {
int i = front;
while (i != rear) {
printf("%d ", queue[i]);
i = (i + 1) % SIZE;
}
printf("%d\n", queue[rear]);
}
}

int main() {
enqueue(10);
enqueue(20);
enqueue(30);
enqueue(40);
display();

dequeue();
display();
 enqueue(50);
enqueue(60);
display();

return 0;
}

7. Write a program to insert the elements {61,16,8,27} into ordered singly

linked list and delete 8,61,27 from the list. Display your list after each insertion
and deletion.

#include <stdio.h>

#include <stdlib.h>

struct Node {

int data;

struct Node* next;

};

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

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

newNode->data = data;

newNode->next = NULL;

if (*head == NULL || (*head)->data >= data) {

newNode->next = *head;

*head = newNode;
 } else {

struct Node* temp = *head;

while (temp->next != NULL && temp->next->data < data)

temp = temp->next;

newNode->next = temp->next;

temp->next = newNode;

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

struct Node* temp = *head, *prev = NULL;

if (temp != NULL && temp->data == data) {

*head = temp->next;

free(temp);

return;

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

prev = temp;

temp = temp->next;

if (temp == NULL) return;

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

void printList(struct Node* head) {

while (head != NULL) {

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

head = head->next;

printf("NULL\n");

int main() {

struct Node* head = NULL;

insert(&head, 61);

insert(&head, 16);

insert(&head, 8);

insert(&head, 27);

printList(head);

delete(&head, 8);

delete(&head, 61);

delete(&head, 27);

printList(head);
 return 0;

8. Write a program for Tower of Hanoi problem using recursion.

#include <stdio.h>

void towerOfHanoi(int n, char from, char to, char aux) {

if (n == 1) {

printf("Move disk 1 from %c to %c\n", from, to);

return;

towerOfHanoi(n-1, from, aux, to);

printf("Move disk %d from %c to %c\n", n, from, to);

towerOfHanoi(n-1, aux, to, from);

int main() {

int n = 3;

towerOfHanoi(n, 'A', 'C', 'B');

return 0;

}
9. Write recursive program to find GCD of 3 numbers.

#include <stdio.h>

int gcd(int a, int b) {

if (b == 0)
return a;
return gcd(b, a % b);
}

int gcd_of_three(int a, int b, int c) {

return gcd(gcd(a, b), c);
}

int main() {
int a = 24, b = 36, c = 60;
printf("GCD of 24, 36, and 60 is: %d\n", gcd_of_three(a, b, c));
return 0;
}

10. Write a program to demonstrate working of stack using linked list.

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

// Define the node structure

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

// Function to push an element onto the stack

void push(struct Node** top, int value) {
struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->data = value;
newNode->next = *top;
*top = newNode;
printf("%d pushed to stack\n", value);
}

// Function to pop an element from the stack

int pop(struct Node** top) {
if (*top == NULL) {
printf("Stack Underflow\n");
return -1;
}
struct Node* temp = *top;
int poppedValue = temp->data;
*top = (*top)->next;
free(temp);
return poppedValue;
}

// Function to display the stack

void display(struct Node* top) {
if (top == NULL) {
printf("Stack is empty\n");
return;
}
printf("Stack elements are: ");
while (top != NULL) {
printf("%d ", top->data);
top = top->next;
}
printf("\n");
}

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

push(&stack, 10);
 push(&stack, 20);
push(&stack, 30);

display(stack);

printf("Popped element is: %d\n", pop(&stack));

display(stack);

return 0;
}