Data Structures Laboratory

Visvesvaraya Technological University (VTU)
Data Structures Laboratory

BSCSL305
Aug 15, 2024
RAJIV GANDHI INSTITUTE OF

TECHNOLOGY
DEPARTMENT OF COMPUTER SCIENCE & ENGINEERING
Bengaluru - 560032
2024
Data Structures Lab BSCL305
DATA STRUCTURES LABORATORY SEMESTER – III
Course Code: BCSL305 CIE Mark: 50

Number of Contact Hours/Week 0:0:2 SEE Marks:
50
Total Number of Lab Contact Hours 28 Exam Hours:

03 Credits – 1
Course Learning Objectives:
This laboratory course enables students to get practical experience in design, develop, implement,
analyse and evaluation/testing of
● Dynamic memory management
● Linear data structures and their applications such as stacks, queues and lists
● Non-Linear data structures and their applications such as trees and graphs
Descriptions (if any):
● Implement all the programs in “C” Programming Language and Linux OS.
Programs List:
1. Develop a Program in C for the following:

a. Declare a calendar as an array of 7 elements (A dynamically Created array) to represent 7
days of a week. Each Element of the array is a structure having three fields. The first field is
the name of the Day (A dynamically allocated String), The second field is the date of the Day
(A integer), the third field is the description of the activity for a particular day (A dynamically
allocated String).
b. Write functions create (), read () and display (); to create the calendar, to read the data from
the keyboard and to print weeks activity details report on screen.
2. Develop a Program in C for the following operations on Strings.

a. Read a main String (STR), a Pattern String (PAT) and a Replace String (REP)
b. Perform Pattern Matching Operation: Find and Replace all occurrences of PAT in STR
with REP if PAT exists in STR. Report suitable messages in case PAT does not exist in
STR Support the program with functions for each of the above operations. Don't use
Built-in functions.
3. Develop a menu driven Program in C for the following operations on STACK of Integers
(Array Implementation of Stack with maximum size MAX)
a. Push an Element on to Stack
b. Pop an Element from Stack
c. Demonstrate how Stack can be used to check Palindrome
d. Demonstrate Overflow and Underflow situations on Stack
Rajiv Gandhi Institute of Technology 2024

2
e. Display the status of Stack f. Exit Support the program with appropriate functions for
each of the above operations 15.09.2023 14.09.2023
4. Develop a Program in C for converting an Infix Expression to Postfix Expression. Program
should support for both parenthesized and free parenthesized expressions with the
operators: +, -, *, /, % (Remainder), ^ (Power) and alphanumeric operands.
5. Develop a Program in C for the following Stack Applications
a. Evaluation of Suffix expression with single digit operands and operators: +, -, *, /, %, ^
b. Solving Tower of Hanoi problem with n disks
6. Develop a menu driven Program in C for the following operations on Circular QUEUE of
Characters (Array Implementation of Queue with maximum size MAX)
a. Insert an Element on to Circular QUEUE
b. Delete an Element from Circular QUEUE
c. Demonstrate Overflow and Underflow situations on Circular QUEUE
d. Display the status of Circular QUEUE
e. Exit Support the program with appropriate functions for each of the above operations
7. Develop a menu driven Program in C for the following operations on Singly Linked List (SLL)
of Student Data with the fields: USN, Name, Programme, Sem, PhNo
a. Create a SLL of N Students Data by using front insertion.
b. Display the status of SLL and count the number of nodes in it
c. Perform Insertion / Deletion at End of SLL
d. Perform Insertion / Deletion at Front of SLL (Demonstration of stack)
e. Exit
8. Develop a menu driven Program in C for the following operations on Doubly Linked List (DLL)
of Employee Data with the fields: SSN, Name, Dept, Designation, Sal, PhNo
a. Create a DLL of N Employees Data by using end insertion.
b. Display the status of DLL and count the number of nodes in it
c. Perform Insertion and Deletion at End of DLL
d. Perform Insertion and Deletion at Front of DLL
e. Demonstrate how this DLL can be used as Double Ended Queue.
f. Exit
9. Develop a Program in C for the following operations on Singly Circular Linked List (SCLL) with
header nodes a. Represent and Evaluate a Polynomial P (x, y, z) = 6x 2 y 2 z-4yz 5 +3x 3
yz+2xy 5 z-2xyz 3 b. Find the sum of two polynomials POLY1(x, y, z) and POLY2(x, y, z) and
store the result in POLYSUM (x, y, z) Support the program with appropriate functions for
each of the above operations
10. Develop a menu driven Program in C for the following operations on Binary Search Tree
(BST) of Integers.
a. Create a BST of N Integers: 6, 9, 5, 2, 8, 15, 24, 14, 7, 8, 5, 2
b. Traverse the BST in In order, Preorder and Post Order
c. Search the BST for a given element (KEY) and report the appropriate message
d. Exit
11. Develop a Program in C for the following operations on Graph(G) of Cities
a. Create a Graph of N cities using Adjacency Matrix.
b. Print all the nodes reachable from a given starting node in a digraph using DFS/BFS
method.
12. Given a File of N employee records with a set K of Keys (4-digit) which uniquely determine
the records in file F. Assume that file F is maintained in memory by a Hash Table (HT) of m
memory locations with L as the set of memory addresses (2-digit) of locations in HT. Let the

3
keys in K and addresses in L are Integers. Develop a Program in C that uses Hash Function H:
K →L as H(K)=K mod m (remainder method), and implement hashing technique to map a
given key K to the address space L. Resolve the collision (if any) using linear probing.
Laboratory Outcomes: The student should be able to:
● Analyse various linear and non-linear data structures
● Demonstrate the working nature of different types of data structures and their
applications
● Use appropriate searching and sorting algorithms for the give scenario.
● Apply the appropriate data structure for solving real world problems
Conduct of Practical Examination:
● Experiment distribution
o For laboratories having only one part: Students are allowed to pick one
experiment from the lot with equal opportunity.
o For laboratories having PART A and PART B: Students are allowed to pick one
experiment from PART A and one experiment from PART B, with equal
opportunity.
● Change of experiment is allowed only once and marks allotted for procedure to be made
zero of the changed part only.
● Marks Distribution (Need to change in accordance with university regulations)
a. For laboratories having only one part – Procedure + Execution + Viva-Voce:
15+70+15 = 100 Marks
b. For laboratories having PART A and PART B i. Part A – Procedure + Execution +
Viva = 6 + 28 + 6 = 40 Marks ii. Part B – Procedure + Execution + Viva = 9 + 42 + 9
= 60 Marks

4
Program 1:
Develop a Program in C for the following:
a. Declare a calendar as an array of 7 elements (A dynamically Created array) to represent 7

days of a week. Each Element of the array is a structure having three fields. The first field is
the name of the Day (A dynamically allocated String), The second field is the date of the Day
(A integer), the third field is the description of the activity for a particular day (A dynamically
allocated String).
b. Write functions create (), read () and display (); to create the calendar, to read the data from
the keyboard and to print weeks activity details report on screen.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// Define the Day structure
typedef struct {
char *dayName;
int date;
char *activity;
} Day;
// Function prototypes
void create(Day **calendar);
void read(Day *calendar);
void display(const Day *calendar);
int main() {
// Create an array of 7 Day structures
Day *calendar = NULL;
create(&calendar);
read(calendar);

5
display(calendar);
// Free allocated memory
for (int i = 0; i < 7; i++) {
free(calendar[i].dayName);
free(calendar[i].activity);
free(calendar);
return 0;
// Function to create the calendar array
void create(Day **calendar) {
*calendar = (Day *)malloc(7 * sizeof(Day));
if (*calendar == NULL) {
perror("Failed to allocate memory for calendar");
exit(EXIT_FAILURE);
const char *daysOfWeek[7] = {
"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"
};
for (int i = 0; i < 7; i++) {
(*calendar)[i].dayName = (char *)malloc((strlen(daysOfWeek[i]) + 1) * sizeof(char));
if ((*calendar)[i].dayName == NULL) {
perror("Failed to allocate memory for day name");
exit(EXIT_FAILURE);
strcpy((*calendar)[i].dayName, daysOfWeek[i]);

6
(*calendar)[i].date = 0; // Initialize date to 0
(*calendar)[i].activity = (char *)malloc(1 * sizeof(char)); // Initialize with empty string
if ((*calendar)[i].activity == NULL) {
perror("Failed to allocate memory for activity");
exit(EXIT_FAILURE);
(*calendar)[i].activity[0] = '\0'; // Set the empty string
// Function to read data from the keyboard
void read(Day *calendar) {
char buffer[256];
for (int i = 0; i < 7; i++) {
printf("Enter date for %s: ", calendar[i].dayName);
if (scanf("%d", &calendar[i].date) != 1) {
fprintf(stderr, "Invalid input for date\n");
exit(EXIT_FAILURE);
// Clear the input buffer
while (getchar() != '\n');
printf("Enter activity for %s: ", calendar[i].dayName);
if (fgets(buffer, sizeof(buffer), stdin) == NULL) {
fprintf(stderr, "Error reading activity\n");
exit(EXIT_FAILURE);
// Remove the newline character from the input string

7
buffer[strcspn(buffer, "\n")] = '\0';
// Allocate memory for the activity
calendar[i].activity = (char *)realloc(calendar[i].activity, (strlen(buffer) + 1) * sizeof(char));
if (calendar[i].activity == NULL) {
perror("Failed to allocate memory for activity");
exit(EXIT_FAILURE);
strcpy(calendar[i].activity, buffer);
// Function to display the calendar details
void display(const Day *calendar) {
printf("\n**********Weekly Calendar**********\n");
printf("%-10s%-8s %-10s\n","DAY","Date","Activity");
for (int i = 0; i < 7; i++) {
printf("%-10s %-5d %-100s\n", calendar[i].dayName, calendar[i].date,
(calendar[i].activity[0] == '\0') ? "NO Activity" : calendar[i].activity);
For linux OS
gcc -o calendar calendar.c
./calendar
Output:

8
Enter date for Monday: 1

Enter activity for Monday: playing tennis
Enter date for Tuesday: 2
Enter activity for Tuesday:
Enter date for Wednesday: 2
Enter activity for Wednesday: attending classes
Enter date for Thursday: 3
Enter activity for Thursday: attending classes
Enter date for Friday: 5
Enter activity for Friday: playing cricket
Enter date for Saturday: 8
Enter activity for Saturday:
Enter date for Sunday: 5
Enter activity for Sunday: rest
**********Weekly Calendar**********
DAY Date Activity
Monday 1 playing tennis
Tuesday 2 NO Activity
Wednesday 2 attending classes
Thursday 3 attending classes
Friday 5 playing cricket
Saturday 8 NO Activity
Sunday 5 rest

9
2. Develop a Program in C for the following operations on Strings.

a. Read a main String (STR), a Pattern String (PAT) and a Replace String (REP)
b. Perform Pattern Matching Operation: Find and Replace all occurrences of PAT in STR
with REP if PAT exists in STR. Report suitable messages in case PAT does not exist in STR
Support the program with functions for each of the above operations. Don't use Built-in
functions.
#include <stdio.h>a
#include <stdlib.h>
#include <string.h>
void readStrings(char **mainStr, char **patternStr, char **replaceStr);
int findPattern(const char *str, const char *pat);
void replacePattern(char *str, const char *pat, const char *rep);
void printString(const char *str);
int main() {
char *mainStr = NULL;
char *patternStr = NULL;
char *replaceStr = NULL;
// Read the strings from the user
readStrings(&mainStr, &patternStr, &replaceStr);
// Perform pattern matching and replacement
if (findPattern(mainStr, patternStr) != -1) {
replacePattern(mainStr, patternStr, replaceStr);
printf("Modified String: ");

10
printString(mainStr);
} else {
printf("Pattern not found in the main string.\n");
// Free allocated memory
free(mainStr);
free(patternStr);
free(replaceStr);
return 0;
// Function to read strings from the user
void readStrings(char **mainStr, char **patternStr, char **replaceStr) {
char buffer[1000];
printf("Enter the main string: ");
fgets(buffer, sizeof(buffer), stdin);
buffer[strcspn(buffer, "\n")] = '\0'; // Remove the trailing newline
*mainStr = (char *)malloc((strlen(buffer) + 1) * sizeof(char));
strcpy(*mainStr, buffer);
printf("Enter the pattern string: ");
*patternStr = (char *)malloc((strlen(buffer) + 1) * sizeof(char));
strcpy(*patternStr, buffer);
printf("Enter the replace string: ");

11
*replaceStr = (char *)malloc((strlen(buffer) + 1) * sizeof(char));
strcpy(*replaceStr, buffer);
// Function to find the pattern in the main string
int findPattern(const char *str, const char *pat) {
int strLen = strlen(str);
int patLen = strlen(pat);
for (int i = 0; i <= strLen - patLen; i++) {
int j;
for (j = 0; j < patLen; j++) {
if (str[i + j] != pat[j]) {
break;
if (j == patLen) {
return i;
return -1; // Pattern not found
// Function to replace the pattern with the replace string
void replacePattern(char *str, const char *pat, const char *rep) {
int strLen = strlen(str);
int patLen = strlen(pat);
int repLen = strlen(rep);
char *result = (char *)malloc((strLen + 1) * sizeof(char));

12
int i = 0, j = 0;
while (str[i]) {
if (findPattern(&str[i], pat) == 0) {
strcpy(&result[j], rep);
j += repLen;
i += patLen;
} else {
result[j++] = str[i++];
result[j] = '\0';
strcpy(str, result);
free(result);
// Function to print a string
void printString(const char *str) {
printf("%s\n", str);
Output:
Enter the main string: The quick brown fox jumps over the lazy dog
Enter the pattern string: fox
Enter the replace string: cat
Modified String: The quick brown cat jumps over the lazy dog

13
or
#include <stdio.h>
#include <string.h>
char str[50], pat[20], rep[20], res[50];

int c = 0, m = 0, i = 0, j = 0, k, flag = 0;
void stringmatch() {
while (str[c] != '\0') {
if (str[m] == pat[i]) {
i++;
m++;
if (pat[i] == '\0') {
flag = 1;
for (k = 0; rep[k] != '\0'; k++, j++) {
res[j] = rep[k];
}
i = 0;
c = m;
}
} else {
res[j] = str[c];
j++;
c++;
m = c;

14
i = 0;
}
}
res[j] = '\0';
}
int main() {
printf("Enter the main string: ");
fgets(str, sizeof(str), stdin);
str[strcspn(str, "\n")] = '\0'; // Remove trailing newline
printf("Enter the pattern string: ");

fgets(pat, sizeof(pat), stdin);
pat[strcspn(pat, "\n")] = '\0'; // Remove trailing newline
printf("Enter the replace string: ");

fgets(rep, sizeof(rep), stdin);
rep[strcspn(rep, "\n")] = '\0'; // Remove trailing newline
printf("\nThe string before pattern match is: %s\n", str);

stringmatch();
if (flag == 1)
printf("The string after pattern match and replace is: %s\n", res);
else
printf("Pattern string is not found\n");
return 0;
}

15
3. Develop a menu driven Program in C for the following operations on STACK of Integers
(Array Implementation of Stack with maximum size MAX) a. Push an Element on to Stack b.
Pop an Element from Stack c. Demonstrate how Stack can be used to check Palindrome d.
Demonstrate Overflow and Underflow situations on Stack e. Display the status of Stack f.
Exit Support the program with appropriate functions for each of the above operations
#include<stdio.h>
#include<stdlib.h>
#define MAX 5
int s[MAX];
int top = -1;
void push(int item);
int pop();
void palindrome();
void display();
void main()
int choice, item;
while(1)
printf("\n\n~~~~~~Menu~~~~~~ : ");
printf("\n=>1.Push an Element to Stack and Overflow demo ");
printf("\n=>2.Pop an Element from Stack and Underflow demo");
printf("\n=>3.Palindrome demo ");
printf("\n=>4.Display ");
printf("\n=>5.Exit");

16
printf("\nEnter your choice: ");
scanf("%d", &choice);
switch(choice)
case 1: printf("\nEnter an element to be pushed: ");
scanf("%d", &item);
push(item);
break;
case 2: item = pop();
if(item != -1)
printf("\nElement popped is: %d", item);
break;
case 3: palindrome();
break;
case 4: display();
break;
case 5: exit(1);
default: printf("\nPlease enter valid choice ") ;
break;
void push(int item)
if(top == MAX-1)
printf("\n~~~~Stack overflow~~~~");
return;

17
top = top + 1 ;
s[top] = item;
int pop()
int item;
if(top == -1)
printf("\n~~~~Stack underflow~~~~");
return -1;
item = s[top];
top = top - 1;
return item;
void display()
int i;
if(top == -1)
printf("\n~~~~Stack is empty~~~~");
return;
printf("\nStack elements are:\n ");
for(i=top; i>=0 ; i--)
printf("| %d |\n", s[i]);
void palindrome()

18
int flag=1,i;
printf("\nStack content are:\n");
for(i=top; i>=0 ; i--)
printf("\nReverse of stack content are:\n");
for(i=0; i<=top; i++)
for(i=0; i<=top/2; i++)
if( s[i] != s[top-i] )
flag = 0;
break;
if(flag == 1)
printf("\nIt is palindrome number");
else
printf("\nIt is not a palindrome number");
OUTPUT:
~~~~~~Menu~~~~~~ :

19
=>1.Push an Element to Stack and Overflow demo
=>2.Pop an Element from Stack and Underflow demo
=>3.Palindrome demo
=>4.Display
=>5.Exit
Enter your choice: 1
Enter an element to be pushed: 1
~~~~~~Menu~~~~~~ :
=>3.Palindrome demo
=>4.Display
=>5.Exit
~~~~~~Menu~~~~~~ :
=>3.Palindrome demo
=>4.Display
=>5.Exit

20
Stack elements are:
| 22 |
|1|
~~~~~~Menu~~~~~~ :
=>3.Palindrome demo
=>4.Display
=>5.Exit
~~~~~~Menu~~~~~~ :
=>3.Palindrome demo
=>4.Display
=>5.Exit
Stack elements are:

21
| 333 |
| 22 |
|1|
~~~~~~Menu~~~~~~ :
=>3.Palindrome demo
=>4.Display
=>5.Exit
~~~~~~Menu~~~~~~ :
=>3.Palindrome demo
=>4.Display
=>5.Exit
Stack elements are:
| 4444 |
| 333 |

22
| 22 |
|1|
~~~~~~Menu~~~~~~ :
=>3.Palindrome demo
=>4.Display
=>5.Exit
~~~~~~Menu~~~~~~ :
=>3.Palindrome demo
=>4.Display
=>5.Exit
~~~~Stack overflow~~~~

23
~~~~~~Menu~~~~~~ :
=>3.Palindrome demo
=>4.Display
=>5.Exit
Stack elements are:
| 55555 |
| 4444 |
| 333 |
| 22 |
|1|
~~~~~~Menu~~~~~~ :
=>3.Palindrome demo
=>4.Display
=>5.Exit
Element popped is: 55555

24
~~~~~~Menu~~~~~~ :
=>3.Palindrome demo
=>4.Display
=>5.Exit
Stack content are:
| 4444 |
| 333 |
| 22 |
|1|
Reverse of stack content are:
|1|
| 22 |
| 333 |
| 4444 |
It is not a palindrome number
~~~~~~Menu~~~~~~ :
=>3.Palindrome demo
=>4.Display
=>5.Exit

25
4. Develop a Program in C for converting an Infix Expression to Postfix Expression. Program

should support for both parenthesized and free parenthesized expressions with the
operators: +, -, *, /, % (Remainder), ^ (Power) and alphanumeric operands.
#include<stdio.h>
#include<stdlib.h>
void evaluate();
void push(char);
char pop();
int prec(char);
char infix[30], postfix[30], stack[30];
int top = -1;
void main()
printf("\nEnter the valid infix expression:\t");
scanf("%s", infix);
evaluate();
printf("\nThe entered infix expression is :\n %s \n", infix);
printf("\nThe corresponding postfix expression is :\n %s \n", postfix);
void evaluate()
int i = 0, j = 0;
char symb, temp;

26
push('#');
for(i=0; infix[i] != '\0'; i++)
symb = infix[i];
switch(symb)
case '(' : push(symb);
break;
case ')' : temp = pop();
while(temp != '(' )
postfix[j] = temp;
j++;
temp = pop();
break;
case '+' :
case '-' :
case '*' :
case '/' :
case '%' :
case '^' :
case '$' : while( prec(stack[top]) >= prec(symb) )
temp = pop();
postfix[j] = temp;
j++;
push(symb);

27
break;
default: postfix[j] = symb;
j++;
while(top > 0)
temp = pop();
postfix[j] = temp;
j++;
postfix[j] = '\0';
void push(char item)
top = top+1;
stack[top] = item;
char pop()
char item;
item = stack[top];
top = top-1;
return item;
int prec(char symb)
int p;

28
switch(symb)
case '#' : p = -1;
break;
case '(' :
case ')' : p = 0;
break;
case '+' :
case '-' : p = 1;
break;
case '*' :
case '/' :
case '%' : p = 2;
break;
case '^' :
case '$' : p = 3;
break;
return p;
OUTPUT:
Enter the valid infix expression: (a+b)+c/d*e
The entered infix expression is :
(a+b)+c/d*e

29
The corresponding postfix expression is :
ab+cd/e*+
5. Develop a Program in C for the following Stack Applications

a. Evaluation of Suffix expression with single digit operands and operators: +, -, *, /, %, ^
b. Solving Tower of Hanoi problem with n disks
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include <math.h> // Include the math header for pow function
#define MAX 100
typedef struct {
int top;
int items[MAX];
} Stack;
void push(Stack *s, int value) {
if (s->top == (MAX - 1)) {
printf("Stack is full\n");
return;
s->items[++(s->top)] = value;
int pop(Stack *s) {
if (s->top == -1) {
printf("Stack is empty\n");
exit(1); // Exit on stack underflow

30
return s->items[(s->top)--];
int evaluateSuffix(char *expr) {
Stack s;
s.top = -1;
int i, op1, op2, result;
char *token;
char delim[] = " ";
token = strtok(expr, delim); // Tokenize based on space
while (token != NULL) {
if (isdigit(token[0])) {
push(&s, atoi(token)); // Convert token to integer and push onto stack
} else {
op2 = pop(&s);
op1 = pop(&s);
switch (token[0]) {
case '+': result = op1 + op2; break;
case '-': result = op1 - op2; break;
case '*': result = op1 * op2; break;
case '/': result = op1 / op2; break;
case '%': result = op1 % op2; break;
case '^': result = (int)pow(op1, op2); break;
default:
printf("Invalid operator\n");
exit(1);
push(&s, result);

31
token = strtok(NULL, delim); // Get next token
return pop(&s); // Final result
int main() {
char expr[MAX];
printf("Enter the suffix expression: ");
fgets(expr, MAX, stdin);
expr[strcspn(expr, "\n")] = 0; // Remove newline character
int result = evaluateSuffix(expr);
printf("Result: %d\n", result);
return 0;
Output:
1.
Enter the suffix expression: 3 4 + 2 * 7 /
Result: 2
2.
Enter the suffix expression: 5 1 2 + 4 * + 3 -
Result: 14

32
b)
#include <stdio.h>
void towerOfHanoi(int n, char from_rod, char to_rod, char aux_rod) {
if (n == 1) {
printf("Move disk 1 from rod %c to rod %c\n", from_rod, to_rod);
return;
towerOfHanoi(n - 1, from_rod, aux_rod, to_rod);
printf("Move disk %d from rod %c to rod %c\n", n, from_rod, to_rod);
towerOfHanoi(n - 1, aux_rod, to_rod, from_rod);
int main() {
int n;
printf("Enter the number of disks: ");
scanf("%d", &n);
towerOfHanoi(n, 'A', 'C', 'B'); // A, B, and C are names of rods
return 0;
Output:
Enter the number of disks: 4
Move disk 1 from rod A to rod B
Move disk 2 from rod A to rod C
Move disk 1 from rod B to rod C
Move disk 1 from rod C to rod A
Move disk 2 from rod C to rod B

33
Move disk 2 from rod B to rod A
Move disk 1 from rod C to rod A

34
6. Develop a menu driven Program in C for the following operations on Circular QUEUE of Characters
(Array Implementation of Queue with maximum size MAX)
A. Insert an Element on to Circular QUEUE

B. Delete an Element from Circular QUEUE
C. Demonstrate Overflow and Underflow situations on Circular QUEUE
D. Display the status of Circular QUEUE
#include <stdio.h>
#include <stdlib.h>
#define MAX 3 // Define maximum size of the circular queue
typedef struct {
char items[MAX];
int front, rear, size;
} CircularQueue;
void initializeQueue(CircularQueue *q);
int isFull(CircularQueue *q);
int isEmpty(CircularQueue *q);
void insert(CircularQueue *q, char item);
char delete(CircularQueue *q);
void display(CircularQueue *q);
void demonstrateOverflowUnderflow(CircularQueue *q);
int main() {
CircularQueue queue;
int choice;
char item;

35
initializeQueue(&queue);
while (1) {
printf("\nCircular Queue Operations Menu:\n");
printf("1. Insert an Element\n");
printf("2. Delete an Element\n");
printf("3. Demonstrate Overflow and Underflow\n");
printf("4. Display Queue Status\n");
printf("5. Exit\n");
printf("Enter your choice: ");
switch (choice) {
case 1:
if (isFull(&queue)) {
printf("Queue is full! Cannot insert element.\n");
} else {
printf("Enter a character to insert: ");
scanf(" %c", &item); // Space before %c to ignore whitespace
insert(&queue, item);
break;
case 2:
if (isEmpty(&queue)) {
printf("Queue is empty! Cannot delete element.\n");
} else {
item = delete(&queue);
printf("Deleted element: %c\n", item);
break;

36
case 3:
demonstrateOverflowUnderflow(&queue);
break;
case 4:
display(&queue);
break;
case 5:
exit(0);
default:
printf("Invalid choice! Please enter a number between 1 and 5.\n");
return 0;
void initializeQueue(CircularQueue *q) {
q->front = 0;
q->rear = -1;
q->size = 0;
int isFull(CircularQueue *q) {
return q->size == MAX;
int isEmpty(CircularQueue *q) {
return q->size == 0;
void insert(CircularQueue *q, char item) {

37
q->rear = (q->rear + 1) % MAX;
q->items[q->rear] = item;
q->size++;
printf("Inserted element: %c\n", item);
char delete(CircularQueue *q) {
char item = q->items[q->front];
q->front = (q->front + 1) % MAX;
q->size--;
return item;
void display(CircularQueue *q) {
if (isEmpty(q)) {
printf("Queue is empty.\n");
return;
printf("Queue elements: ");
int i, count;
for (i = 0, count = q->front; i < q->size; i++) {
printf("%c ", q->items[count]);
count = (count + 1) % MAX;
printf("\n");
void demonstrateOverflowUnderflow(CircularQueue *q) {
printf("Demonstrating Overflow and Underflow...\n");

38
// Try inserting elements until the queue is full
for (int i = 0; i < MAX; i++) {
insert(q, 'A' + i);
insert(q, 'Z'); // This should show that the queue is full
// Try deleting all elements from the queue
while (!isEmpty(q)) {
delete(q);
delete(q); // This should show that the queue is empty
Output:
Circular Queue Operations Menu:
1. Insert an Element
2. Delete an Element
3. Demonstrate Overflow and Underflow
4. Display Queue Status
5. Exit
Enter a character to insert: a
Inserted element: a
5. Exit

39
Enter a character to insert: b
Inserted element: b
5. Exit
Enter a character to insert: c
Inserted element: c
5. Exit
Queue is full! Cannot insert element.
5. Exit
Queue elements: a b c

40
5. Exit

41
7. Develop a menu driven Program in C for the following operations on Singly Linked List (SLL) of
Student Data with the fields: USN, Name, Programme, Sem, PhNo
a. Create a SLL of N Students Data by using front insertion.

b. Display the status of SLL and count the number of nodes in it
c. Perform Insertion / Deletion at End of SLL
d. Perform Insertion / Deletion at Front of SLL (Demonstration of stack)
e. Exit
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// Define maximum sizes

#define MAX_NAME_LENGTH 100
#define MAX_PROG_LENGTH 50
#define MAX_PHNO_LENGTH 15
// Define the structure for student data

typedef struct Student {
char usn[15];
char name[MAX_NAME_LENGTH];
char programme[MAX_PROG_LENGTH];
int sem;
char phno[MAX_PHNO_LENGTH];
struct Student *next;
} Student;
Student* createStudent();
void displayList(Student *head);
void insertFront(Student **head, Student *newStudent);
void insertEnd(Student **head, Student *newStudent);
void deleteFront(Student **head);
void deleteEnd(Student **head);
int countNodes(Student *head);
void freeList(Student *head);
int main() {
Student *head = NULL; // Initialize head of the list
int choice;
Student *newStudent;
int nodeCount;
while (1) {
printf("\nSingly Linked List Operations Menu:\n");
printf("1. Create SLL of N Students (Front Insertion)\n");

42
printf("2. Display SLL and Count Nodes\n");

printf("3. Insert at End of SLL\n");
printf("4. Delete from End of SLL\n");
printf("5. Insert at Front of SLL\n");
printf("6. Delete from Front of SLL\n");
getchar(); // Consume newline character left by scanf
switch (choice) {
case 1:
{
int n;
printf("Enter the number of students: ");
scanf("%d", &n);
getchar(); // Consume newline character
for (int i = 0; i < n; i++) {

newStudent = createStudent();
insertFront(&head, newStudent);
}
printf("SLL created with %d students using front insertion.\n", n);
}
break;
case 2:
displayList(head);
nodeCount = countNodes(head);
printf("Number of nodes: %d\n", nodeCount);
break;
case 3:
insertEnd(&head, newStudent);
printf("Inserted student at the end of the list.\n");
break;
case 4:
deleteEnd(&head);
printf("Deleted student from the end of the list.\n");
break;
case 5:
insertFront(&head, newStudent);
printf("Inserted student at the front of the list.\n");
break;
case 6:
deleteFront(&head);

43
printf("Deleted student from the front of the list.\n");

break;
case 7:
freeList(head);
exit(0);
default:
}
}
return 0;
}
// Function to create a new student

Student* createStudent() {
Student *newStudent = (Student*)malloc(sizeof(Student));
if (!newStudent) {
printf("Memory allocation failed!\n");
exit(1);
}
printf("Enter USN: ");

fgets(newStudent->usn, sizeof(newStudent->usn), stdin);
newStudent->usn[strcspn(newStudent->usn, "\n")] = '\0'; // Remove newline character
printf("Enter Name: ");

fgets(newStudent->name, sizeof(newStudent->name), stdin);
newStudent->name[strcspn(newStudent->name, "\n")] = '\0'; // Remove newline character
printf("Enter Programme: ");

fgets(newStudent->programme, sizeof(newStudent->programme), stdin);
newStudent->programme[strcspn(newStudent->programme, "\n")] = '\0'; // Remove newline
character
printf("Enter Semester: ");

scanf("%d", &newStudent->sem);
printf("Enter Phone Number: ");

fgets(newStudent->phno, sizeof(newStudent->phno), stdin);
newStudent->phno[strcspn(newStudent->phno, "\n")] = '\0'; // Remove newline character
newStudent->next = NULL;
return newStudent;
}
// Function to display the linked list

void displayList(Student *head) {
if (head == NULL) {

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

return;
}
printf("Student List:\n");
Student *temp = head;
while (temp != NULL) {
printf("USN: %s\n", temp->usn);
printf("Name: %s\n", temp->name);
printf("Programme: %s\n", temp->programme);
printf("Semester: %d\n", temp->sem);
printf("Phone Number: %s\n", temp->phno);
printf("-------------\n");
temp = temp->next;
}
}
// Function to insert a student at the front of the list

void insertFront(Student **head, Student *newStudent) {
newStudent->next = *head;
*head = newStudent;
}
// Function to insert a student at the end of the list

void insertEnd(Student **head, Student *newStudent) {
if (*head == NULL) {
*head = newStudent;
return;
}
Student *temp = *head;

while (temp->next != NULL) {
temp = temp->next;
}
temp->next = newStudent;
}
// Function to delete a student from the front of the list

void deleteFront(Student **head) {
printf("The list is empty. Cannot delete.\n");
return;
}

*head = (*head)->next;
free(temp);
}
// Function to delete a student from the end of the list

void deleteEnd(Student **head) {

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

while (temp->next->next != NULL) {
temp = temp->next;
}
free(temp->next);
temp->next = NULL;
}
// Function to count the number of nodes in the list

int countNodes(Student *head) {
int count = 0;
Student *temp = head;
count++;
temp = temp->next;
}
return count;
}
// Function to free all nodes in the list

void freeList(Student *head) {
Student *temp;
while (head != NULL) {
temp = head;
head = head->next;
free(temp);
}
}
Output:
Singly Linked List Operations Menu:

1. Create SLL of N Students (Front Insertion)
2. Display SLL and Count Nodes
3. Insert at End of SLL
4. Delete from End of SLL
5. Insert at Front of SLL
6. Delete from Front of SLL
7. Exit

46
Enter the number of students: 2

Enter USN: 23
Enter Name: Sam
Enter Programme: comp
Enter Semester: 3
Enter Phone Number: 1111
Enter USN: 34
Enter Name: Shyam
Enter Programme: be
Enter Semester: 3
SLL created with 2 students using front insertion.
Singly Linked List Operations Menu:

1. Create SLL of N Students (Front Insertion)
2. Display SLL and Count Nodes
3. Insert at End of SLL
4. Delete from End of SLL
5. Insert at Front of SLL
6. Delete from Front of SLL
7. Exit
8. Develop a menu driven Program in C for the following operations on Doubly Linked List (DLL) of
Employee Data with the fields: SSN, Name, Dept, Designation, Sal, PhNo
A. Create a DLL of N Employees Data by using end insertion.

B. Display the status of DLL and count the number of nodes in it
C. Perform Insertion and Deletion at End of DLL
D. Perform Insertion and Deletion at Front of DLL
E. Demonstrate how this DLL can be used as Double Ended Queue.
F. Exit
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_NAME_LENGTH 100
#define MAX_DEPT_LENGTH 50

47
#define MAX_DESG_LENGTH 50
#define MAX_PHNO_LENGTH 15
// Define the structure for employee data
typedef struct Employee {
char ssn[15];
char name[MAX_NAME_LENGTH];
char dept[MAX_DEPT_LENGTH];
char designation[MAX_DESG_LENGTH];
float sal;
char phno[MAX_PHNO_LENGTH];
struct Employee *next;
struct Employee *prev;
} Employee;
Employee* createEmployee();
void displayList(Employee *head);
void insertEnd(Employee **head, Employee **tail, Employee *newEmployee);
void deleteEnd(Employee **head, Employee **tail);
void insertFront(Employee **head, Employee **tail, Employee *newEmployee);
void deleteFront(Employee **head, Employee **tail);
int countNodes(Employee *head);
void demonstrateDeque(Employee *head, Employee *tail);
void freeList(Employee *head);
int main() {
Employee *head = NULL, *tail = NULL;
int choice;
Employee *newEmployee;
int nodeCount;

48
while (1) {
printf("\nDoubly Linked List Operations Menu:\n");
printf("1. Create DLL of N Employees (End Insertion)\n");
printf("2. Display DLL and Count Nodes\n");
printf("3. Insert at End of DLL\n");
printf("4. Delete from End of DLL\n");
printf("5. Insert at Front of DLL\n");
printf("6. Delete from Front of DLL\n");
printf("7. Demonstrate DLL as Double Ended Queue\n");
switch (choice) {
case 1:
int n;
printf("Enter the number of employees: ");
scanf("%d", &n);
for (int i = 0; i < n; i++) {
newEmployee = createEmployee();
insertEnd(&head, &tail, newEmployee);
printf("DLL created with %d employees using end insertion.\n", n);
break;

49
case 2:
displayList(head);
nodeCount = countNodes(head);
printf("Number of nodes: %d\n", nodeCount);
break;
case 3:
printf("Inserted employee at the end of the list.\n");
break;
case 4:
deleteEnd(&head, &tail);
printf("Deleted employee from the end of the list.\n");
break;
case 5:
insertFront(&head, &tail, newEmployee);
printf("Inserted employee at the front of the list.\n");
break;
case 6:
deleteFront(&head, &tail);
printf("Deleted employee from the front of the list.\n");
break;
case 7:
demonstrateDeque(head, tail);
break;

50
case 8:
freeList(head);
exit(0);
default:
return 0;
// Function to create a new employee
Employee* createEmployee() {
Employee *newEmployee = (Employee*)malloc(sizeof(Employee));
if (!newEmployee) {
printf("Memory allocation failed!\n");
exit(1);
printf("Enter SSN: ");
fgets(newEmployee->ssn, sizeof(newEmployee->ssn), stdin);
newEmployee->ssn[strcspn(newEmployee->ssn, "\n")] = '\0'; // Remove newline character
printf("Enter Name: ");
fgets(newEmployee->name, sizeof(newEmployee->name), stdin);
newEmployee->name[strcspn(newEmployee->name, "\n")] = '\0'; // Remove newline character
printf("Enter Department: ");
fgets(newEmployee->dept, sizeof(newEmployee->dept), stdin);

51
newEmployee->dept[strcspn(newEmployee->dept, "\n")] = '\0'; // Remove newline character
printf("Enter Designation: ");
fgets(newEmployee->designation, sizeof(newEmployee->designation), stdin);
newEmployee->designation[strcspn(newEmployee->designation, "\n")] = '\0'; // Remove newline

character
printf("Enter Salary: ");
scanf("%f", &newEmployee->sal);
printf("Enter Phone Number: ");
fgets(newEmployee->phno, sizeof(newEmployee->phno), stdin);
newEmployee->phno[strcspn(newEmployee->phno, "\n")] = '\0'; // Remove newline character
newEmployee->next = NULL;
newEmployee->prev = NULL;
return newEmployee;
// Function to display the doubly linked list
void displayList(Employee *head) {
if (head == NULL) {
printf("The list is empty.\n");
return;
printf("Employee List:\n");
Employee *temp = head;
printf("SSN: %s\n", temp->ssn);

52
printf("Name: %s\n", temp->name);
printf("Department: %s\n", temp->dept);
printf("Designation: %s\n", temp->designation);
printf("Salary: %.2f\n", temp->sal);
printf("Phone Number: %s\n", temp->phno);
printf("-------------\n");
temp = temp->next;
// Function to insert an employee at the end of the list
void insertEnd(Employee **head, Employee **tail, Employee *newEmployee) {
if (*tail == NULL) {
*head = *tail = newEmployee;
return;
(*tail)->next = newEmployee;
newEmployee->prev = *tail;
*tail = newEmployee;
// Function to delete an employee from the end of the list
void deleteEnd(Employee **head, Employee **tail) {
if (*tail == NULL) {
return;
Employee *temp = *tail;
if (*head == *tail) { // Only one element in the list

53
*head = *tail = NULL;
} else {
*tail = (*tail)->prev;
(*tail)->next = NULL;
free(temp);
// Function to insert an employee at the front of the list
void insertFront(Employee **head, Employee **tail, Employee *newEmployee) {
*head = *tail = newEmployee;
return;
newEmployee->next = *head;
(*head)->prev = newEmployee;
*head = newEmployee;
// Function to delete an employee from the front of the list
void deleteFront(Employee **head, Employee **tail) {
return;
Employee *temp = *head;
if (*head == *tail) { // Only one element in the list
*head = *tail = NULL;
} else {

54
*head = (*head)->next;
(*head)->prev = NULL;
free(temp);
// Function to count the number of nodes in the list
int countNodes(Employee *head) {
int count = 0;
Employee *temp = head;
count++;
temp = temp->next;
return count;
// Function to demonstrate DLL as a double-ended queue
void demonstrateDeque(Employee *head, Employee *tail) {
printf("Demonstrating DLL as a Double Ended Queue:\n");
// Insertion at front
printf("Inserting at front:\n");
Employee *newEmployee = createEmployee();
insertFront(&head, &tail, newEmployee);
displayList(head);
// Insertion at end
printf("Inserting at end:\n");

55
displayList(head);
// Deletion from front
printf("Deleting from front:\n");
deleteFront(&head, &tail);
displayList(head);
// Deletion from end
printf("Deleting from end:\n");
deleteEnd(&head, &tail);
displayList(head);
// Function to free all nodes in the list
void freeList(Employee *head) {
Employee *temp;
while (head != NULL) {
temp = head;
head = head->next;
free(temp);
Output:
Doubly Linked List Operations Menu:
1. Create DLL of N Employees (End Insertion)
2. Display DLL and Count Nodes
3. Insert at End of DLL
4. Delete from End of DLL

56
5. Insert at Front of DLL
6. Delete from Front of DLL
7. Demonstrate DLL as Double Ended Queue
8. Exit
Enter the number of employees: 2
Enter SSN: 2
Enter Name: Ram
Enter Department: CSE
Enter Designation: AP
Enter Salary: 10000
Enter SSN: 4
Enter Name: Gyan
Enter Department: EC
Enter Designation: AP
Enter Salary: 20000
DLL created with 2 employees using end insertion.
8. Exit
Employee List:

57
SSN: 2
Name: Ram
Department: CSE
Designation: AP
Salary: 10000.00
Phone Number: 2222
-------------
SSN: 4
Name: Gyan
Department: EC
Designation: AP
Salary: 20000.00
Phone Number: 22333
-------------
Number of nodes: 2
8. Exit
Deleted employee from the front of the list.

58
8. Exit
Employee List:
SSN: 4
Name: Gyan
Department: EC
Designation: AP
Salary: 20000.00
Phone Number: 22333
-------------
Number of nodes: 1
8. Exit

59
9. Develop a Program in C for the following operations on Singly Circular Linked List (SCLL) with
header nodes a. Represent and Evaluate a Polynomial P (x, y, z) = 6x 2 y 2 z-4yz 5 +3x 3 yz+2xy 5 z-
2xyz 3 b. Find the sum of two polynomials POLY1(x, y, z) and POLY2(x, y, z) and store the result in
POLYSUM (x, y, z) Support the program with appropriate functions for each of the above operations
#include <stdio.h>
#include <stdlib.h>
#include <math.h> // Include the math library for pow function
// Node structure for singly circular linked list
typedef struct Node {
int coeff;

60
int x_exp;
int y_exp;
int z_exp;
struct Node *next;
} Node;
// Function to create a new node
Node* createNode(int coeff, int x_exp, int y_exp, int z_exp) {
Node* newNode = (Node*)malloc(sizeof(Node));
newNode->coeff = coeff;
newNode->x_exp = x_exp;
newNode->y_exp = y_exp;
newNode->z_exp = z_exp;
newNode->next = newNode; // Initially points to itself
return newNode;
// Function to insert a node into the circular linked list
void insertNode(Node** header, int coeff, int x_exp, int y_exp, int z_exp) {
Node* newNode = createNode(coeff, x_exp, y_exp, z_exp);
if (*header == NULL) {
*header = newNode;
} else {
Node* temp = *header;
while (temp->next != *header) {
temp = temp->next;
temp->next = newNode;
newNode->next = *header;

61
// Function to print the polynomial
void printPolynomial(Node* header) {
if (header == NULL) {
printf("Polynomial is empty.\n");
return;
Node* temp = header;
do {
printf("%d*x^%d*y^%d*z^%d", temp->coeff, temp->x_exp, temp->y_exp, temp->z_exp);
temp = temp->next;
if (temp != header) {
printf(" + ");
} while (temp != header);
printf("\n");
// Function to evaluate the polynomial
int evaluatePolynomial(Node* header, int x, int y, int z) {
int result = 0;
Node* temp = header;
do {
int termValue = temp->coeff;
termValue *= pow(x, temp->x_exp);
termValue *= pow(y, temp->y_exp);
termValue *= pow(z, temp->z_exp);
result += termValue;
temp = temp->next;
} while (temp != header);
return result;

62
// Function to add two polynomials
Node* addPolynomials(Node* header1, Node* header2) {
Node* result = NULL;
Node* temp1 = header1;
Node* temp2 = header2;
do {
int found = 0;
Node* tempResult = result;
do {
if (tempResult && temp1->x_exp == tempResult->x_exp && temp1->y_exp == tempResult-

>y_exp && temp1->z_exp == tempResult->z_exp) {
tempResult->coeff += temp1->coeff;
found = 1;
break;
tempResult = tempResult ? tempResult->next : NULL;
} while (tempResult != result);
if (!found) {
insertNode(&result, temp1->coeff, temp1->x_exp, temp1->y_exp, temp1->z_exp);
temp1 = temp1->next;
} while (temp1 != header1);
do {
int found = 0;
Node* tempResult = result;
do {
if (tempResult && temp2->x_exp == tempResult->x_exp && temp2->y_exp == tempResult-

>y_exp && temp2->z_exp == tempResult->z_exp) {

63
found = 1;
break;
tempResult = tempResult ? tempResult->next : NULL;
} while (tempResult != result);
if (!found) {
insertNode(&result, temp2->coeff, temp2->x_exp, temp2->y_exp, temp2->z_exp);
temp2 = temp2->next;
} while (temp2 != header2);
return result;
// Main function
int main() {
Node* poly1 = NULL;
Node* poly2 = NULL;
// Add terms to polynomial 1
insertNode(&poly1, 6, 2, 2, 1);
insertNode(&poly1, -4, 0, 1, 5);
// Add terms to polynomial 2 (example terms)

64
// Print polynomials
printf("Polynomial 1:\n");
printPolynomial(poly1);
printf("Polynomial 2:\n");
printPolynomial(poly2);
// Evaluate polynomial 1
int x = 1, y = 1, z = 1;
int evalResult = evaluatePolynomial(poly1, x, y, z);
printf("Evaluation of Polynomial 1 at x=%d, y=%d, z=%d: %d\n", x, y, z, evalResult);
// Add polynomials
Node* polySum = addPolynomials(poly1, poly2);
printf("Sum of Polynomial 1 and Polynomial 2:\n");
printPolynomial(polySum);
return 0;
Output:
Polynomial 1:
6*x^2*y^2*z^1 + -4*x^0*y^1*z^5 + 3*x^3*y^1*z^1 + 2*x^1*y^5*z^1 + -2*x^1*y^1*z^3
Polynomial 2:
2*x^2*y^2*z^0 + -1*x^0*y^1*z^4
Evaluation of Polynomial 1 at x=1, y=1, z=1: 5
Sum of Polynomial 1 and Polynomial 2:
6*x^2*y^2*z^1 + -4*x^0*y^1*z^5 + 3*x^3*y^1*z^1 + 2*x^1*y^5*z^1 + -2*x^1*y^1*z^3 +

2*x^2*y^2*z^0 + -1*x^0*y^1*z^4

65
10. Develop a menu driven Program in C for the following operations on Binary Search Tree (BST) of
Integers.
e. Create a BST of N Integers: 6, 9, 5, 2, 8, 15, 24, 14, 7, 8, 5, 2

f. Traverse the BST in In order, Preorder and Post Order
g. Search the BST for a given element (KEY) and report the appropriate message
h. Exit
#include <stdio.h>
#include <stdlib.h>
// Node structure for BST
typedef struct Node {
int data;
struct Node* left;
struct Node* right;

66
} Node;
// Function to create a new node
Node* createNode(int data) {
Node* newNode = (Node*)malloc(sizeof(Node));
newNode->data = data;
newNode->left = NULL;
newNode->right = NULL;
return newNode;
// Function to insert a new node into the BST
Node* insert(Node* root, int data) {
if (root == NULL) {
return createNode(data);
if (data < root->data) {
root->left = insert(root->left, data);
} else if (data > root->data) {
root->right = insert(root->right, data);
return root;
// Function for In-order traversal
void inOrder(Node* root) {
if (root != NULL) {
inOrder(root->left);
printf("%d ", root->data);
inOrder(root->right);

67
// Function for Pre-order traversal
void preOrder(Node* root) {
if (root != NULL) {
preOrder(root->left);
preOrder(root->right);
// Function for Post-order traversal
void postOrder(Node* root) {
if (root != NULL) {
postOrder(root->left);
postOrder(root->right);
// Function to search for a given element in the BST
Node* search(Node* root, int key) {
if (root == NULL || root->data == key) {
return root;
if (key < root->data) {
return search(root->left, key);
return search(root->right, key);

68
// Function to display menu and perform operations
void menu(Node* root) {
int choice, key;
while (1) {
printf("\nMenu:\n");
printf("1. In-order Traversal\n");
printf("2. Pre-order Traversal\n");
printf("3. Post-order Traversal\n");
printf("4. Search for an Element\n");
switch (choice) {
case 1:
printf("In-order Traversal: ");
inOrder(root);
printf("\n");
break;
case 2:
printf("Pre-order Traversal: ");
preOrder(root);
printf("\n");
break;
case 3:
printf("Post-order Traversal: ");
postOrder(root);
printf("\n");
break;
case 4:
printf("Enter element to search: ");

69
scanf("%d", &key);
if (search(root, key)) {
printf("Element %d found in the BST.\n", key);
} else {
printf("Element %d not found in the BST.\n", key);
break;
case 5:
printf("Exiting...\n");
return;
default:
printf("Invalid choice. Please try again.\n");
// Main function
int main() {
Node* root = NULL;
int elements[] = {6, 9, 5, 2, 8, 15, 24, 14, 7, 8, 5, 2};
int n = sizeof(elements) / sizeof(elements[0]);
// Create the BST
for (int i = 0; i < n; i++) {
root = insert(root, elements[i]);
// Display menu and perform operations
menu(root);
return 0;

70
Output:
Menu:
1. In-order Traversal
2. Pre-order Traversal
3. Post-order Traversal
4. Search for an Element
5. Exit
In-order Traversal: 2 5 6 7 8 9 14 15 24
Menu:
5. Exit
Pre-order Traversal: 6 5 2 9 8 7 15 14 24
Menu:
5. Exit
Pre-order Traversal: 6 5 2 9 8 7 15 14 24

71
Menu:
5. Exit
Enter element to search: 2
Element 2 found in the BST.
Menu:
5. Exit
11. Develop a Program in C for the following operations on Graph(G) of Cities

c. Create a Graph of N cities using Adjacency Matrix.
d. Print all the nodes reachable from a given starting node in a digraph using DFS/BFS
method.
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#define MAX_VERTICES 100
// Function to initialize the adjacency matrix

void initializeGraph(int graph[MAX_VERTICES][MAX_VERTICES], int n) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
graph[i][j] = 0; // Initialize all edges to 0 (no edge)
}
}
}
// Function to add an edge to the graph

72
void addEdge(int graph[MAX_VERTICES][MAX_VERTICES], int u, int v) {

graph[u][v] = 1; // Directed edge from u to v
}
// Function to print the adjacency matrix

void printGraph(int graph[MAX_VERTICES][MAX_VERTICES], int n) {
printf("Adjacency Matrix:\n");
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
printf("%d ", graph[i][j]);
}
printf("\n");
}
}
// Depth-First Search (DFS)

void DFS(int graph[MAX_VERTICES][MAX_VERTICES], int n, int start, bool visited[]) {
printf("%d ", start);
visited[start] = true;
for (int i = 0; i < n; i++) {

if (graph[start][i] && !visited[i]) {
DFS(graph, n, i, visited);
}
}
}
// Breadth-First Search (BFS)

void BFS(int graph[MAX_VERTICES][MAX_VERTICES], int n, int start) {
bool visited[MAX_VERTICES] = { false };
int queue[MAX_VERTICES];
int front = 0, rear = 0;
visited[start] = true;
queue[rear++] = start;
while (front < rear) {

int node = queue[front++];
printf("%d ", node);
for (int i = 0; i < n; i++) {

if (graph[node][i] && !visited[i]) {
visited[i] = true;
queue[rear++] = i;
}
}
}
}
int main() {
int graph[MAX_VERTICES][MAX_VERTICES];

73
int n, e, u, v, start;
int choice;
printf("Enter the number of cities (vertices): ");

scanf("%d", &n);
// Initialize and create the graph

initializeGraph(graph, n);
printf("Enter the number of edges: ");

scanf("%d", &e);
printf("Enter the edges (u v) where u -> v:\n");

for (int i = 0; i < e; i++) {
scanf("%d %d", &u, &v);
addEdge(graph, u, v);
}
// Print the graph

printGraph(graph, n);
printf("\nChoose traversal method:\n");

printf("1. DFS\n");
printf("2. BFS\n");
printf("Enter starting node: ");

scanf("%d", &start);
bool visited[MAX_VERTICES] = { false };
switch (choice) {
case 1:
printf("DFS traversal starting from node %d:\n", start);
DFS(graph, n, start, visited);
printf("\n");
break;
case 2:
printf("BFS traversal starting from node %d:\n", start);
BFS(graph, n, start);
printf("\n");
break;
default:
printf("Invalid choice.\n");
}
return 0;
}
Output:

74
Enter the number of cities (vertices): 3

Enter the number of edges: 4
Enter the edges (u v) where u -> v:
02
01
12
10
Adjacency Matrix:
011
101
000
Choose traversal method:

1. DFS
2. BFS
Enter starting node: 0
DFS traversal starting from node 0:
012

75
12. Given a File of N employee records with a set K of Keys (4-digit) which uniquely determine the
records in file F. Assume that file F is maintained in memory by a Hash Table (HT) of m memory
locations with L as the set of memory addresses (2-digit) of locations in HT. Let the keys in K and
addresses in L are Integers. Develop a Program in C that uses Hash Function H: K →L as H(K)=K mod
m (remainder method), and implement hashing technique to map a given key K to the address space
L. Resolve the collision (if any) using linear probing.
#include <stdio.h>
#include <stdlib.h>
#define MAX_KEYS 100
#define TABLE_SIZE 10 // Size of the hash table
// Hash Table structure
typedef struct {
int key;
int isOccupied; // 1 if slot is occupied, 0 otherwise
} HashTable;
// Function to initialize the hash table
void initializeHashTable(HashTable ht[], int size) {
for (int i = 0; i < size; i++) {
ht[i].key = -1; // -1 indicates an empty slot
ht[i].isOccupied = 0;

76
// Hash function
int hashFunction(int key, int m) {
return key % m;
// Function to insert a key into the hash table
void insert(HashTable ht[], int key, int size) {
int index = hashFunction(key, size);
int originalIndex = index;
int i = 0;
while (ht[index].isOccupied) {
if (ht[index].key == key) {
printf("Key %d already exists in the hash table.\n", key);
return;
i++;
index = (originalIndex + i) % size;
if (index == originalIndex) {
printf("Hash table is full, cannot insert key %d.\n", key);
return;
ht[index].key = key;
ht[index].isOccupied = 1;
printf("Key %d inserted at index %d.\n", key, index);

77
// Function to display the hash table
void displayHashTable(HashTable ht[], int size) {
printf("Hash Table:\n");
for (int i = 0; i < size; i++) {
if (ht[i].isOccupied) {
printf("Index %d: Key %d\n", i, ht[i].key);
} else {
printf("Index %d: Empty\n", i);
int main() {
HashTable hashTable[TABLE_SIZE];
int keys[MAX_KEYS];
int n, key;
// Initialize hash table
initializeHashTable(hashTable, TABLE_SIZE);
printf("Enter the number of keys to insert: ");
scanf("%d", &n);
printf("Enter %d keys (4-digit integers):\n", n);
for (int i = 0; i < n; i++) {
scanf("%d", &keys[i]);
insert(hashTable, keys[i], TABLE_SIZE);
// Display the hash table

78
displayHashTable(hashTable, TABLE_SIZE);
return 0;
Output :
Enter the number of keys to insert: 4
Enter 4 keys (4-digit integers):
1234
Key 1234 inserted at index 4.
3452
2421
4223
Hash Table:
Index 0: Empty
Index 1: Key 2421
Index 2: Key 3452
Index 3: Key 4223
Index 4: Key 1234
Index 5: Empty
Index 6: Empty
Index 7: Empty
Index 8: Empty
Index 9: Empty

79

Data Structures Laboratory

Uploaded by

Copyright:

Available Formats

Data Structures Laboratory

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Data Structures Laboratory

Uploaded by

Copyright:

Available Formats

Visvesvaraya Technological University (VTU)

Data Structures Laboratory

Aug 15, 2024

RAJIV GANDHI INSTITUTE OF

DATA STRUCTURES LABORATORY SEMESTER – III

Course Code: BCSL305 CIE Mark: 50

Total Number of Lab Contact Hours 28 Exam Hours:

Course Learning Objectives:

● Dynamic memory management

Descriptions (if any):

1. Develop a Program in C for the following:

2. Develop a Program in C for the following operations on Strings.

Rajiv Gandhi Institute of Technology 2024

Rajiv Gandhi Institute of Technology 2024

Laboratory Outcomes: The student should be able to:

● Analyse various linear and non-linear data structures

Conduct of Practical Examination:

Rajiv Gandhi Institute of Technology 2024

Develop a Program in C for the following:

a. Declare a calendar as an array of 7 elements (A dynamically Created array) to represent 7

// Define the Day structure

void create(Day **calendar);

void read(Day *calendar);

void display(const Day *calendar);

// Create an array of 7 Day structures

Day *calendar = NULL;

Rajiv Gandhi Institute of Technology 2024

// Free allocated memory

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

// Function to create the calendar array

void create(Day **calendar) {

*calendar = (Day *)malloc(7 * sizeof(Day));

perror("Failed to allocate memory for calendar");

const char *daysOfWeek[7] = {

"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"

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

(*calendar)[i].dayName = (char *)malloc((strlen(daysOfWeek[i]) + 1) * sizeof(char));

perror("Failed to allocate memory for day name");

Rajiv Gandhi Institute of Technology 2024

(*calendar)[i].date = 0; // Initialize date to 0

(*calendar)[i].activity = (char *)malloc(1 * sizeof(char)); // Initialize with empty string

perror("Failed to allocate memory for activity");

(*calendar)[i].activity[0] = '\0'; // Set the empty string

// Function to read data from the keyboard

void read(Day *calendar) {

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

printf("Enter date for %s: ", calendar[i].dayName);

fprintf(stderr, "Invalid input for date\n");

// Clear the input buffer

while (getchar() != '\n');

printf("Enter activity for %s: ", calendar[i].dayName);

if (fgets(buffer, sizeof(buffer), stdin) == NULL) {

fprintf(stderr, "Error reading activity\n");

// Remove the newline character from the input string

Rajiv Gandhi Institute of Technology 2024

buffer[strcspn(buffer, "\n")] = '\0';

// Allocate memory for the activity

calendar[i].activity = (char *)realloc(calendar[i].activity, (strlen(buffer) + 1) * sizeof(char));

perror("Failed to allocate memory for activity");

calendar = (Day )malloc(7 * sizeof(Day));

(calendar)[i].dayName = (char )malloc((strlen(daysOfWeek[i]) + 1) * sizeof(char));

(calendar)[i].activity = (char )malloc(1 * sizeof(char)); // Initialize with empty string

calendar[i].activity = (char )realloc(calendar[i].activity, (strlen(buffer) + 1) sizeof(char));

void readStrings(char mainStr, char patternStr, char **replaceStr);

int findPattern(const char str, const char pat);

void replacePattern(char str, const char pat, const char *rep);

void readStrings(char mainStr, char patternStr, char **replaceStr) {

mainStr = (char )malloc((strlen(buffer) + 1) * sizeof(char));

patternStr = (char )malloc((strlen(buffer) + 1) * sizeof(char));

replaceStr = (char )malloc((strlen(buffer) + 1) * sizeof(char));

int findPattern(const char str, const char pat) {

void replacePattern(char str, const char pat, const char *rep) {

char result = (char )malloc((strLen + 1) * sizeof(char));