Data Structures Lab Record Format

JSS MAHAVIDYAPEETHA
JSS ACADEMY OF TECHNICAL EDUCATION, NOIDA

Department of CSDS
S. DATE OF NAME OF DATE OF TEACHER’S

NO. PERFORM EXPERINMENT SUBMISSION SIGNATURE
Array handling through
1 functions
To search an array for

2 the given element using
linear and binary search
To sort an array using
3 iterative sorting algorithms
To sort an array using

4 recursive sorting
algorithms
To implement singly
5 linked lists
To implement stack
6 operations using linked
Lists
To implement queues
7 using arrays.
To implement binary
8 search trees.
To implement graphs &

9 traversals
To find minimum spanning

10 tree of given
Graph
JSS Academy of Technical Education, Noida Department of CSDS
Experiment 1
Aim: To use functions for array handling
Programming Assignment: Write a program using functions to find

 the total number of even elements in a given array
 the maximum element in a given array
Pre-Lab Work:
Q1) How are single dimensional arrays used in C programs?
Q2) How is an array passed as an argument to a function in C programs?
Program:
#include <stdio.h>
int traverse(int *a){

int count = 0;
for (int i = 0; i < 10; i++){
if (*(i + a) == 0)
break;
count++;}
return count;};
void insert(int *a){

int b;
int c;
int value;
printf("Enter the index at which you want to insert an element and the value: ");
scanf("%d %d", &b, &value);
c = traverse(a);
for (int i = c - 1; i > b - 1; i--){

*(a + i + 1) = *(a + i);};
*(a + b) = value;
printf("Array after insertion is: ");

for (int i = 0; i <= 10; i++){
if (*(i + a) == 0)
break;
printf(" %d ", *(i + a));
};
};
void delete(int *a){
int c;
int b;
printf("Enter the index at which you want to delete an element: ");
scanf("%d", &b);
Data Structures Lab (BCS 351) Sajal Singhal 2200911540092
c = traverse(a);
for (int i = b; i <= c; i++){
*(a + i) = *(a + i + 1);
};
printf("Array after deletion is: ");
for (int i = 0; i <= 10; i++){
if (*(i + a) == 0)
break;
printf(" %d ", *(i + a));
};
};
int main(){
int arr[10] = {23, 24, 63, 78, 53};
char a;
printf("Enter the operation you want t o perform in the array\n");
printf("Enter 'I' for insertion, 'D' for deletion and 'T' for traversal:");
scanf("%c", &a);
printf("Array is: ");

for (int i = 0; i < 10; i++){
if (arr[i] == 0)
break;
printf(" %d ", arr[i]);};
printf("\n");
switch (a){
case 'I':
insert(arr);
break;
case 'D':
delete(arr);
break;
case 'T':
traverse(arr);
break;
};
return 0;
};

Output:

Experiment 2
Aim: To search an array for the given element using linear (or sequential) and binary search
Programming Assignment: Write a menu driven program in C which searches an array for
the input element.
Pre-Lab Work: Write the linear and binary search algorithms and compute their complexity
Program:
Linear search:-
#include <stdio.h>
int main(){
int size,arr[100],key,i;
printf("Enter the size of array: ");

scanf("%d",&size);
printf("Enter the elements of the array: ");

for(i=0;i<size;i++)
scanf("%d",&arr[i]);
printf("Enter the element to be searched: ");

scanf("%d",&key);
for(i=0;i<10;i++){
if((*(arr+i))==key){
printf("Element found at index %d\n",i);};
};
return 0;
};
Binary search:-
#include <stdio.h>
int main(){
int size,arr[100],key,i;
int low=0,high,mid;
printf("Enter the size of array: ");

scanf("%d", &size);
printf("Enter the elements of the array: ");

for (i = 0; i < size; i++)
scanf("%d", &arr[i]);
printf("Enter the element to be searched: ");
scanf("%d", &key);
high=size;
while(low<=high){
mid=(low+high)/2;
if (arr[mid]==key){
printf("Element found at index %d.\n",mid);
break;
}
else if(arr[mid]<key){
low=mid+1;
}
else{
high=mid-1;
}
};
return 0;
};
Output:
Linear search:-
Binary search:-

Experiment 3
Aim: To sort an array using iterative sorting algorithms
Programming Assignment: Write a menu driven program in C which sorts an array using
selection, bubble and insertion sorting algorithms. The expectations from the program are as
follows:-
 The output of the program MUST be user friendly and self-explanatory.
 The program MUST display the array at the end of each iteration.
 Proper test cases MUST be designed to exhibit the best case, average case and worst-
case behavior of the algorithms.
Pre-Lab Work: Write selection, bubble and insertion sorting algorithms and compute their
complexity in best, worst and average cases.
Program:
#include <stdio.h>
void InsertionSort(int arr[]);

void SelectionSort(int arr[]);
void BubbleSort(int arr[]);
void PrintArray(int arr[]);
int main(){
int ar[5],ans;
printf("Enter array: ");

scanf("%d %d %d %d %d",&ar[0],&ar[1],&ar[2],&ar[3],&ar[4]);
printf("\nChoose type of sorting\n");

printf("1 -> Insertion Sort\n");
printf("2 -> Selection Sort\n");
printf("3 -> Bubble Sort\n");
scanf("%d",&ans);
switch(ans){
case 1:
InsertionSort(ar);
break;
case 2:
SelectionSort(ar);
break;
case 3:
BubbleSort(ar);
break;
}
return 0;
}

void PrintArray(int arr[]){

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

int i, key, j;
for (i=1;i<5;i++) {
key=arr[i];
j=i-1;
while(j>=0&&arr[j]>key){
arr[j+1]=arr[j];
j=j-1;
}
arr[j+1]=key;
PrintArray(arr);
}
printf("\nsorted array is :- ");
PrintArray(arr);
}
void SelectionSort(int arr[]){

int i, j, min_idx;
for (i = 0; i < 4; i++){
min_idx = i;
for (j = i+1; j < 5; j++)
if (arr[j] < arr[min_idx])
min_idx = j;
if(min_idx != i){
int temp = arr[min_idx];
arr[min_idx] = arr[i];
arr[i] = temp;
}
PrintArray(arr);
}
PrintArray(arr);
}
void BubbleSort(int arr[]){

int i, j, swapped;
for (i = 0; i < 4; i++) {
swapped = 0;
for (j = 0; j < 4 - i; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
JSS Academy
arr[jof+Technical Education, Noida
1] = temp; Department of CSDS
swapped = 1;
}
}
PrintArray(arr);
if (swapped == 0)
break;
}
PrintArray(arr);
}
Output:

Experiment 4
Aim: To sort an array using recursive sorting algorithms
Programming Assignment: Modify the program of Experiment 3 to include Merge Sort

and Quick Sort Algorithms. The expectations from the program are as follows: -
 The output of the program MUST be user friendly and self-explanatory.
 The merged array MUST be displayed after each call to the merge function.
 The array after each partitioning step must be displayed.
 Proper test cases MUST be designed to exhibit the best case, average case and worst-
case behavior of the algorithms.
Pre-Lab Work: Write the Merge Sort and Quick Sort algorithms and compute their
complexity in best, worst and average cases.
Program:
#include <stdio.h>
void PrintArray(int arr[]);

void merge(int arr[], int l, int m, int r);
void mergeSort(int arr[], int l, int r);
int partition(int arr[], int low, int high);
void quickSort(int arr[], int low, int high);
int main(){
int ar[5],ans;
printf("Enter array: ");

scanf("%d %d %d %d %d",&ar[0],&ar[1],&ar[2],&ar[3],&ar[4]);
printf("\nChoose type of sorting\n");

printf("1 -> Merge Sort\n");
printf("2 -> Quick Sort\n");
scanf("%d",&ans);
switch(ans){
case 1:
mergeSort(ar,0,4);
break;
case 2:
quickSort(ar,0,4);
break;
}
printf("\nSorted array:\n");
PrintArray(ar);
return 0;
}
void PrintArray(int arr[]){

for(int i=0;i<5;i++)
printf("%d\t",arr[i]);
printf("\n");
}
void merge(int arr[], int l, int m, int r) {

int i, j, k;
int n1 = m - l + 1;
int n2 = r - m;
int L[n1], R[n2];
for (i = 0; i < n1; i++)
L[i] = arr[l + i];
for (j = 0; j < n2; j++)
R[j] = arr[m + 1 + j];
i = 0;
j = 0;
k = l;
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++;
}
PrintArray(arr);
}
void mergeSort(int arr[], int l, int r) {

if (l < r) {
int m = l + (r - l) / 2;
mergeSort(arr, l, m);
mergeSort(arr, m + 1, r);
printf("partition:\n");
PrintArray(arr);
merge(arr, l, m, r);
JSS}}Academy of Technical Education, Noida Department of CSDS
int partition(int arr[], int low, int high) {

int pivot = arr[high];
int i = (low - 1);
for (int j = low; j <= high - 1; j++) {
if (arr[j] < pivot) {
i++;
int t = arr[i];
arr[i] = arr[j];
arr[j] = t;
PrintArray(arr);
}
}
int t = arr[i + 1];
arr[i + 1] = arr[high];
arr[high] = t;
PrintArray(arr);
return (i + 1);
}
void quickSort(int arr[], int low, int high) {

if (low < high) {
printf("partition:\n");
PrintArray(arr);
int pi = partition(arr, low, high);
quickSort(arr, low, pi - 1);
quickSort(arr, pi + 1, high);
}
}

Output:

Experiment 5
Aim: To implement singly linked
lists
Programming Assignment: Write a program to implement singly linked lists using the
following functions
1. Create a linked list
2. Insert before a given item in the linked list
3. Delete an item from the linked list
4. Display the linked lit
Note:-
 The program should be menu driven. The menu should contain options for create,
insert, delete, display and quit.
 Make sure that create function should be called only once.
 Functions should be called on the basis of user’s choice till the user enters the choice
to quit.
Pre-Lab Work: Write the algorithms for 2, 3 and 4 functions and compute their complexity.
Program:
#include <stdio.h>
#include<stdlib.h>
struct Node{
int data;
struct Node* next;
}*head,*second,*third,*fourth;
void print(struct Node* ptr){

printf("The list is: ");
while(ptr!=NULL){
printf(" %d ",ptr->data);
ptr=ptr->next;
};
printf("\n");
};
void traverse(struct Node* ptr){

while (ptr!=NULL){
ptr=ptr->next;
};
printf("Traverse complete!\n");
};
struct Node* insert_begin(struct Node* head,int i1){

struct Node* new=(struct Node*)malloc(sizeof(struct Node));
new->data=i1;
new->next=head;
return new;
};
struct Node* insert_specific(struct Node* head,int i1,int indexI){

struct Node* ptr=head;
int i=1;
while(i!=indexI-1){
ptr=ptr->next;
i++;
};
new->data=i1;
new->next=ptr->next;
ptr->next=new;
return head;
};
struct Node* insert_end(struct Node* head,int i1){

while(ptr->next!=NULL){
ptr=ptr->next;
};
new->data=i1;
new->next=ptr->next;
ptr->next=new;
return head;
};
struct Node* delete_begin(struct Node* head){

struct Node* ptr =head;
head=head->next;
free(ptr);
return head;
};
struct Node* delete_specific(struct Node* head, int indexD){
struct Node* ptr =head;
int i=1;
while(i!=indexD-1){
ptr=ptr->next;
i++;
};
struct Node* p=ptr->next;
ptr->next=p->next;
free(p);
return head;};
struct Node* delete_end(struct Node* head){
struct Node* p=head->next;
while(p->next!=NULL){
ptr=ptr->next;
p=p->next;
};
ptr->next=p->next;
free(p);
return head;
};
int main(){
head=(struct Node*)malloc(sizeof(struct Node));
second=(struct Node*)malloc(sizeof(struct Node));
third=(struct Node*)malloc(sizeof(struct Node));
fourth=(struct Node*)malloc(sizeof(struct Node));
head->data=29;
head->next=second;
second->data=45;
second->next=third;
third->data=21;
third->next=fourth;
fourth->data=82;
fourth->next=NULL;
char x='y';
while(x=='y'){
printf("The list before any operation is: \n");
print(head);
char a;
printf("Enter the operation to be performed in linklist\n");
printf("Enter T for traversal\n");
printf("Enter I for insertion\n");
printf("Enter D for deletion\n");
scanf("%c",&a);
switch(a){
case'T':
printf("We are initiating traversal.\n");
traverse(head);
break;
case'I':
int b;
printf("We are performing insertion\n");

printf("Enter 1 to insert in beginning\n");
printf("Enter 2 to insert in specific location\n");
printf("Enter 3 to insert at last\n");
scanf("%d",&b);
int i1;
printf("Enter the value to be inserted: ");
scanf("%d",&i1);
int indexI;
switch(b){
case 1:
printf("You choose to insert at beginning of list\n");
head=insert_begin(head,i1);
print(head);
break;
case 2:
printf("You choose to insert at specific location of list\n");
printf("Enter the index at which you want to insert the given value\n");
scanf("%d",&indexI);
head=insert_specific(head,i1,indexI);
print(head);
break;
case 3:
printf("You choose to insert at end of list\n");
head=insert_end(head,i1);
print(head);
break;
default: printf("Invalid input insert");

break;
}
break;
case'D':
int e;
printf("We are performing deletion\n");
printf("Enter 1 to delete from beginning\n");
printf("Enter 2 to delete from specific\n");
printf("Enter 3 to delete from last\n");
scanf("%d",&e);
int indexD;
switch(e){
case 1:
printf("You choose to delete from beginning of list\n");
head=delete_begin(head);

print(head);
break;
case 2:
printf("You choose to delete at specific location of list\n");
printf("Enter the index at which you want to delete the given value\n");
scanf("%d",&indexD);
head=delete_specific(head,indexD);
print(head);
break;
case 3:
printf("You choose to delete at end of list\n");
head=delete_end(head);
print(head);
break;
default: printf("Invalid input delete");

break;
};
break;
default: printf("Invalid input outer");
};
fflush(stdin);
printf("\nDo you want to repeat any operation?\n");
printf("Enter 'y' for yes and 'n' for no.\n");
scanf("%c",&x);
printf("\n");
fflush(stdin);
};
printf("\nEnd of program\n");
};

Output:


Experiment 6
Aim: To implement stack operations using linked lists
Programming Assignment: Write a program to implement a stack of integers using linked

lists. The program should contain following functions
1. IsEmpty() – to check if the stack is empty
2. Push an item on stack
3. Pop an item from stack
4. Display the items of the stack from top to bottom of the stack.
Note:-
 The program should be menu driven. The menu should contain options for calling
the functions written by you repeatedly till the option to quit is chosen.
Pre-Lab Work: How is a stack implemented using linked lists?
Program:
#include <stdio.h>
#include<stdlib.h>
struct node{
int data;
struct node* next;
}*top;
void print(struct node* top){

int a[100],i=0;
struct node* ptr=top;
printf("The stack is: ");
while(ptr!=NULL && i!=99){
a[i]=ptr->data;
i++;
ptr=ptr->next;
};
for(i=i-1;i>=0;i--){
printf(" %d ",a[i]);
};
printf("\n");
};
struct node* pop(struct node* head){

struct node* ptr=head;
head=head->next;
free(ptr);
return head;
};

struct node* push(struct node* head, int a){
struct node* new=(struct node*)malloc(sizeof(struct node));
new->data=a;
new->next=head;
return new;
};
void main()
{
top=(struct node*)malloc(sizeof(struct node));
top->data=35;
top->next=NULL;
printf("Initially the stack has only one element\n");
int x=1;
while(x==1){
printf("Choose the operation you want to perform from below:\n");
printf("1.PUSH\n2.POP\n3.Display\n");
printf("Enter here:");
int c;
scanf("%d",&c);
switch(c){
case 3: print(top);
break;
case 2: top=pop(top);
print(top);
break;
case 1: int a;
printf("Enter the number you want to push:");
scanf("%d",&a);
top=push(top,a);
print(top);
break;
default: printf("Invalid Input");
};
fflush(stdin);

printf("Enter '1' for yes and '0' for no.\n");
scanf("%d",&x);
fflush(stdin);
};
printf("End of program");
};

Output:

Experiment 7
Aim: To implement queues using arrays.
Programming Assignment: Write a program to implement a queue of alphabets using

circular arrays. The program should contain following functions
1. IsEmpty() – to check if the queue is empty
2. Add an item to the queue
3. Remove an item from the queue
4. Display the items of the queue from first to last.
Note:-
 The program should be menu driven. The menu should contain options for calling the
functions written by you repeatedly till the option to quit is chosen.
Pre-Lab Work: How are queues implemented using arrays? What are the conditions for
overflow and underflow?
Program:
#include <stdio.h>
#include<stdlib.h>
int queue[100]={43},front=0,rear=0;
int c;
void enque(){
if(rear==99){
printf("The queue is full\n");
return;
};
int e;
printf("Enter the element to be inserted: ");
scanf("%d",&e);
if(front==-1){
front=0;
rear=0;
queue[rear]=e;
return;
};
rear=rear+1;
queue[rear]=e;
};
void deque(){
if(front==-1){
printf("The queue is empty\n");
return;
};
front=front+1;
};
void display(){
printf("The elements of queue are: ");
for(int i=front;i<=rear;i++){
printf(" %d",queue[i]);
};
printf("\n");
};
int main()
{
printf("The maximum elements the queue can accomodate = 100 \n");
printf("Initiatlly the queue has one element\n");
display();
int x=1;
while(x==1){
printf("The list of operations are given below to be performed\n");
printf("Enter the respective number for below operations\n");
printf("1. Enque\n2. Deque\n\n");
printf("Enter here: ");
scanf("%d",&c);
switch(c){
case 1:
enque();
display();
break;
case 2:
deque();
display();
break;
default:
printf("Invalid input");
break;
};
fflush(stdin);
printf("Type '1' for yes and '0' for no.\n");
scanf("%d",&x);
printf("\n");
fflush(stdin);
};
printf("End of program");
return 0;
};

Output:

Experiment 8
Aim: To implement binary search tree.

Programming Assignment: Write a program to implement a binary search tree containing
numbers as key elements using linked implementation. The program should contain following
functions.
1. In-order traversal
2. Pre-order traversal
3. Post-order traversal
4. Insert a key
5. Delete a key
Note:-
 The program should be menu driven. The menu should contain options for calling the
functions written by you repeatedly till the option to quit is chosen.
Pre-Lab Work: What are the cases encountered during deletion of a key from a BST? How are
they handled?
Program:
#include <stdio.h>
#include <stdlib.h>
struct Node {
int data;
struct Node *left;
struct Node *right;
};
struct Node* createNode(int data)

struct Node* insert(struct Node* root, int data)
void inorder(struct Node* root)
void preorder(struct Node* root)
void postorder(struct Node* root)
struct Node* minValueNode(struct Node* node)
struct Node* deleteNode(struct Node* root, int key)
int main() {
struct Node* root = NULL;
int choice, data;
while (1) {
printf("\nBinary Search Tree Operations:\n");
printf("1. Insert Element\n");
printf("2. Delete Element\n");
printf("3. Inorder Traversal\n");
printf("4. Preorder Traversal\n");
printf("5. Postorder Traversal\n");
printf("6. Exit\n");
printf("Enter your choice: ");
scanf("%d", &choice);
switch (choice) {
case 1:
printf("Enter data to insert: ");
scanf("%d", &data);
root = insert(root, data);
break;
case 2:
printf("Enter data to delete: ");
scanf("%d", &data);
root = deleteNode(root, data);
break;
case 3:
printf("Inorder Traversal: ");
inorder(root);
printf("\n");
break;
case 4:
printf("Preorder Traversal: ");
preorder(root);
printf("\n");
break;
case 5:
printf("Postorder Traversal: ");
postorder(root);
printf("\n");
break;
case 6:
exit(0);
default:
printf("Invalid choice!\n");}}
return 0;}
struct Node* createNode(int data) {

struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->data = data;
newNode->left = newNode->right = NULL;
return newNode;}
struct Node* insert(struct 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;}
void inorder(struct Node* root) {
if (root != NULL) {
inorder(root->left);
printf("%d ", root->data);
inorder(root->right);
}}
void preorder(struct Node* root) {
if (root != NULL) {

preorder(root->left);
preorder(root->right);
}}
void postorder(struct Node* root) {
if (root != NULL) {
postorder(root->left);
postorder(root->right);
}}
struct Node* minValueNode(struct Node* node) {
struct Node* current = node;
while (current && current->left != NULL)
current = current->left;
return current;}
struct Node* deleteNode(struct Node* root, int key) {
if (root == NULL)
return root;
if (key < root->data)
root->left = deleteNode(root->left, key);
else if (key > root->data)
root->right = deleteNode(root->right, key);
else {
if (root->left == NULL) {
struct Node* temp = root->right;
free(root);
return temp;
} else if (root->right == NULL) {
struct Node* temp = root->left;
free(root);
return temp;}
struct Node* temp = minValueNode(root->right);
root->data = temp->data;
root->right = deleteNode(root->right, temp->data);}
return root;}

Output:



Experiment 9
Aim: To implement graphs &

traversal.
Programming Assignment: Write a program to implement a graphs containing numbers as key
elements using adjacency lists and adjacency matrix. Write functions for breadth first and depth
first graph traversal.
Pre-Lab Work:
1) Compare the two graph representation methods
2) Differentiate between BFS and DFS of graphs
Program:
#include <stdio.h>
#include <stdlib.h>
#define MAX_VERTICES 100
struct Node {
int data;
struct Node* next;
};
struct Graph {
int numVertices;
struct Node** adjLists;
int* visited;
};
struct Node* createNode(int data);

struct Graph* createGraph(int vertices);
void addEdge(struct Graph* graph, int src, int dest);
void printGraph(struct Graph* graph);
void DFS(struct Graph* graph, int vertex);
void BFS(struct Graph* graph, int startVertex);
int main() {
struct Graph* graph = createGraph(5);
addEdge(graph, 0, 1);
printf("Graph:\n");
printGraph(graph);
printf("\nDFS Traversal:\n");
DFS(graph, 0);
// Resetting visited array for BFS
int i;
JSSfor
Academy
(i = 0; i <ofgraph->numVertices;
Technical Education,i++)
Noida
{ Department of CSDS
graph->visited[i] = 0;}
printf("\nBFS Traversal:\n");
BFS(graph, 0);
return 0;
}
struct Node* createNode(int data) {
struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->data = data;
newNode->next = NULL;
return newNode;
}
struct Graph* createGraph(int vertices) {
struct Graph* graph = (struct Graph*)malloc(sizeof(struct Graph));
graph->numVertices = vertices;
graph->adjLists = (struct Node**)malloc(vertices * sizeof(struct Node*));
graph->visited = (int*)malloc(vertices * sizeof(int));
int i;
for (i = 0; i < vertices; i++) {
graph->adjLists[i] = NULL;
graph->visited[i] = 0;}
return graph;
}
void addEdge(struct Graph* graph, int src, int dest) {
struct Node* newNode = createNode(dest);
newNode->next = graph->adjLists[src];
graph->adjLists[src] = newNode;
newNode = createNode(src);
newNode->next = graph->adjLists[dest];
graph->adjLists[dest] = newNode;}
void printGraph(struct Graph* graph) {
int v;
for (v = 0; v < graph->numVertices; v++) {
struct Node* temp = graph->adjLists[v];
printf("Vertex %d: ", v);
while (temp) {
printf("%d -> ", temp->data);
temp = temp->next;}
printf("NULL\n");}}
void DFS(struct Graph* graph, int vertex) {

struct Node* adjList = graph->adjLists[vertex];
struct Node* temp = adjList;
graph->visited[vertex] = 1;
printf("Visited %d \n", vertex);
while (temp != NULL) {
int connectedVertex = temp->data;
if (graph->visited[connectedVertex] == 0) {
DFS(graph, connectedVertex);}
temp = temp->next;}}
void BFS(struct Graph* graph, int startVertex) {

JSSstruct
Academy
Node*ofqueue[MAX_VERTICES];
Technical Education, Noida Department of CSDS
int front = 0, rear = 0;
graph->visited[startVertex] = 1;
queue[rear++] = graph->adjLists[startVertex];
while (front < rear) {
struct Node* currentNode = queue[front++];
printf("Visited %d \n", currentNode->data);
while (currentNode) {
int adjVertex = currentNode->data;
if (graph->visited[adjVertex] == 0) {
queue[rear++] = graph->adjLists[adjVertex];
graph->visited[adjVertex] = 1;}
currentNode = currentNode->next;
}}}
Output:

Experiment 10
Aim: To find minimum spanning tree of given graph
Programming Assignment: Write a program to find MST of a given graph.
Pre-Lab Work:
1) What is minimum spanning tree?
2) Differentiate between Prim’s and Kruskal’s algorithms
Program:
#include <stdio.h>
#include <limits.h>
#define V 5
int minKey(int key[], int mstSet[]);

void printMST(int parent[], int graph[V][V]);
void primMST(int graph[V][V]);
int main() {
int graph[V][V] = {
{0, 2, 0, 6, 0},
{2, 0, 3, 8, 5},
{0, 3, 0, 0, 7},
{6, 8, 0, 0, 9},
{0, 5, 7, 9, 0}
};
primMST(graph);
return 0;
}
int minKey(int key[], int mstSet[]) {
int min = INT_MAX, min_index;
for (int v = 0; v < V; v++)
if (mstSet[v] == 0 && key[v] < min)
min = key[v], min_index = v;
return min_index;}
void printMST(int parent[], int graph[V][V]) {

printf("Edge \tWeight\n");
for (int i = 1; i < V; i++)
printf("%d - %d \t%d \n", parent[i], i, graph[i][parent[i]]);}
void primMST(int graph[V][V]) {

int parent[V];
int key[V];
int mstSet[V];
for (int i = 0; i < V; i++)
key[i] = INT_MAX, mstSet[i] = 0;
key[0] = 0;
parent[0] = -1;
for (int count = 0; count < V - 1; count++) {
int u = minKey(key, mstSet);
mstSet[u] = 1;
for (int v = 0; v < V; v++)
if (graph[u][v] && mstSet[v] == 0 && graph[u][v] < key[v])
parent[v] = u, key[v] = graph[u][v];}
printMST(parent, graph);}
Output:

Data Structures Lab Record Format

Uploaded by

Document Information

Original Description:

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 Lab Record Format

Uploaded by

Copyright:

Available Formats

JSS MAHAVIDYAPEETHA

JSS ACADEMY OF TECHNICAL EDUCATION, NOIDA

S. DATE OF NAME OF DATE OF TEACHER’S

To search an array for

To sort an array using

To implement graphs &

To find minimum spanning

Programming Assignment: Write a program using functions to find

Q2) How is an array passed as an argument to a function in C programs?

int traverse(int *a){

void insert(int *a){

for (int i = c - 1; i > b - 1; i--){

printf("Array after insertion is: ");

printf("Array is: ");

Data Structures Lab (BCS 351) Sajal Singhal 2200911540092

Data Structures Lab (BCS 351) Sajal Singhal 2200911540092

printf("Enter the size of array: ");

printf("Enter the elements of the array: ");

printf("Enter the element to be searched: ");

printf("Enter the size of array: ");

printf("Enter the elements of the array: ");

Data Structures Lab (BCS 351) Sajal Singhal 2200911540092

void InsertionSort(int arr[]);

printf("Enter array: ");

printf("\nChoose type of sorting\n");

Data Structures Lab (BCS 351) Sajal Singhal 2200911540092

void PrintArray(int arr[]){

void InsertionSort(int arr[]){

void SelectionSort(int arr[]){

void BubbleSort(int arr[]){

Data Structures Lab (BCS 351) Sajal Singhal 2200911540092

Programming Assignment: Modify the program of Experiment 3 to include Merge Sort

void PrintArray(int arr[]);

printf("Enter array: ");

printf("\nChoose type of sorting\n");

void PrintArray(int arr[]){

void merge(int arr[], int l, int m, int r) {

void mergeSort(int arr[], int l, int r) {

int partition(int arr[], int low, int high) {

void quickSort(int arr[], int low, int high) {

Data Structures Lab (BCS 351) Sajal Singhal 2200911540092

Data Structures Lab (BCS 351) Sajal Singhal 2200911540092

void print(struct Node* ptr){

void traverse(struct Node* ptr){

struct Node* insert_begin(struct Node* head,int i1){

struct Node* insert_specific(struct Node* head,int i1,int indexI){

struct Node* insert_end(struct Node* head,int i1){

struct Node* delete_begin(struct Node* head){

Data Structures Lab (BCS 351) Sajal Singhal 2200911540092

default: printf("Invalid input insert");

Data Structures Lab (BCS 351) Sajal Singhal 2200911540092

default: printf("Invalid input delete");

Data Structures Lab (BCS 351) Sajal Singhal 2200911540092

Data Structures Lab (BCS 351) Sajal Singhal 2200911540092

Data Structures Lab (BCS 351) Sajal Singhal 2200911540092

Programming Assignment: Write a program to implement a stack of integers using linked

void print(struct node* top){

struct node* pop(struct node* head){

Data Structures Lab (BCS 351) Sajal Singhal 2200911540092

printf("Initially the stack has only one element\n");

printf("\nDo you want to repeat any operation?\n");

Data Structures Lab (BCS 351) Sajal Singhal 2200911540092

Data Structures Lab (BCS 351) Sajal Singhal 2200911540092