DATA STRUCTURE AND ALGORITHM LAB 2

IV/2nd YEAR/CSE

TO ADD NEW LAB

1. Write a program to implement an in-order traversal of a binary tree and print the nodes.
2. Write a program to implement a pre-order traversal of a binary tree and print the nodes.
3. Write a program to implement a post-order traversal of a binary tree and print the nodes.
4. Write a program to implement a menu-driven program for binary tree traversal (in-order,
pre-order, post-order) and searching.
5. Write a program to count the number of nodes in a binary tree.
6. Write a program to find the height of the tree.
7. Write a program to check if the binary tree is balanced or not.
8. Write a program to search a number in a Binary Search Tree (BST).
9. Write a program to insert a node in a Binary Search Tree (BST).
10. Write a program to delete a node from a Binary Search Tree (BST).
11. Write a program to implement insertion and search operations in a tree.
12. Write a program to calculate the balance factor of each node of the AVL tree.
13. Write a program to implement a max-heap and perform heap sort on an array of integers.
14. Write a program to implement a priority queue using a max heap.
15. Write a program to create a graph using an adjacency matrix.
16. Write a program to create a graph using an adjacency list.
17. Write a program to perform Depth-First Search (DFS) on a graph.
18. Write a program to perform Breadth-First Search (BFS) on a graph.
19. Write a program to check if there is a path between two nodes in a graph using DFS.
20. Write a program to find all the vertices reachable from a given vertex in a graph using
BFS.
21. Write a program to detect a cycle in an undirected graph using DFS.
22. Write a program to detect a cycle in a directed graph using DFS.
23. Write a program to find the degree of each vertex in an undirected graph.
24. Write a program to count the number of connected components in an undirected graph.
25. Write a program to implement Dijkstra's Algorithm.
26. Write a program to implement Prim's Algorithm.
27. Write a program to implement Kruskal's Algorithm.
28. Write a program to implement Floyd-Warshall's all-pair shortest path algorithm.
29. Write a program to implement Bellman-Ford Algorithm.
30. Write a program to implement Longest Common Subsequence (LCS).
31. Write a program to implement the sum of subset problem using backtracking.

LAB NUMBER/QUESTION NUMBER [AS MENTIONED IN CODETANTRA LAB]

Lab no. 1/S.NO.1&In-Order Traversal of a
Binary Tree
#include <stdio.h>
#include <stdlib.h>
struct Node {
int data;
struct Node* left;
struct Node* right;
};
struct Node* createNode(int data) {
struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->data = data;
newNode->left = newNode->right = NULL;
return newNode;
}
struct Node* constructTree() {
int data;
printf("Enter data for node (-1 for no node): ");
scanf("%d", &data);
if (data == -1)
return NULL;
struct Node* newNode = createNode(data);
printf("Enter left child of %d\n", data);
newNode->left = constructTree();
printf("Enter right child of %d\n", data);
newNode->right = constructTree();
return newNode;
}
void preorderTraversal(struct Node* root) {
if (root == NULL)
 return;
printf("%d ", root->data);
preorderTraversal(root->left);
preorderTraversal(root->right);
}
int main() {
struct Node* root = NULL;

printf("Construct the binary tree:\n");

root = constructTree();
printf("Pre-Order Traversal: ");
preorderTraversal(root);
printf("\n");
return 0;
}
OUTPUT

Test Case 1: Simple Binary Tree

Enter data for node (-1 for no node): 1
Enter left child of 1
Enter data for node (-1 for no node): 2
Enter left child of 2
Enter data for node (-1 for no node): -1
Enter right child of 2
Enter data for node (-1 for no node): -1
Enter right child of 1
Enter data for node (-1 for no node): 3
Enter left child of 3
Enter data for node (-1 for no node): -1
Enter right child of 3
Enter data for node (-1 for no node): -1
Expected Output:
Pre-Order Traversal: 1 2 3

Test Case 2: Larger Binary Tree

Enter data for node (-1 for no node): 10
Enter left child of 10
Enter data for node (-1 for no node): 5
Enter left child of 5
Enter data for node (-1 for no node): 2
Enter left child of 2
Enter data for node (-1 for no node): -1
Enter right child of 2
Enter data for node (-1 for no node): -1
Enter right child of 5
Enter data for node (-1 for no node): 7
Enter left child of 7
Enter data for node (-1 for no node): -1
Enter right child of 7
Enter data for node (-1 for no node): -1
Enter right child of 10
Enter data for node (-1 for no node): 15
Enter left child of 15
Enter data for node (-1 for no node): 12
Enter left child of 12
Enter data for node (-1 for no node): -1
Enter right child of 12
Enter data for node (-1 for no node): -1
Enter right child of 15
Enter data for node (-1 for no node): 20
Enter left child of 20
Enter data for node (-1 for no node): -1
Enter right child of 20
Enter data for node (-1 for no node): -1

Expected Output:
Pre-Order Traversal: 10 5 2 7 15 12 20

Test Case 3: Empty Tree

Enter data for node (-1 for no node): -1

Expected Output:
Pre-Order Traversal:

Lab no. 1/S.NO.2&Pre-Order Traversal of a

Binary Tree

#include <stdio.h>
#include <stdlib.h>
struct Node {
int data;
struct Node* left;
struct Node* right;
};
struct Node* createNode(int data) {
struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->data = data;
newNode->left = newNode->right = NULL;
return newNode;
}
struct Node* constructTree() {
int data;
printf("Enter data for node (-1 for no node): ");
scanf("%d", &data);
if (data == -1)
return NULL;
struct Node* newNode = createNode(data);
printf("Enter left child of %d\n", data);
newNode->left = constructTree();
printf("Enter right child of %d\n", data);
newNode->right = constructTree();
return newNode;
}
void preorderTraversal(struct Node* root) {
if (root == NULL)
return;
printf("%d ", root->data);
preorderTraversal(root->left);
preorderTraversal(root->right);
}
int main() {
struct Node* root = NULL;
printf("Construct the binary tree:\n");
root = constructTree();
printf("Pre-Order Traversal: ");
preorderTraversal(root);
printf("\n");
return 0;
}

Test Cases

Test Case 1: Full Binary Tree

Input:Construct the binary tree:

Enter data for node (-1 for no node): 1
Enter left child of 1
Enter data for node (-1 for no node): 2
Enter left child of 2
Enter data for node (-1 for no node): 4
Enter left child of 4
Enter data for node (-1 for no node): -1
Enter right child of 4
Enter data for node (-1 for no node): -1
Enter right child of 2
Enter data for node (-1 for no node): 5
Enter left child of 5
Enter data for node (-1 for no node): -1
Enter right child of 5
Enter data for node (-1 for no node): -1
Enter right child of 1
Enter data for node (-1 for no node): 3
Enter left child of 3
Enter data for node (-1 for no node): 6
Enter left child of 6
Enter data for node (-1 for no node): -1
Enter right child of 6
Enter data for node (-1 for no node): -1
Enter right child of 3
Enter data for node (-1 for no node): 7
Enter left child of 7
Enter data for node (-1 for no node): -1
Enter right child of 7
Enter data for node (-1 for no node): -1

Output:
Pre-Order Traversal: 1 2 4 5 3 6 7

Test Case 2: Skewed Tree (Left-heavy)

Input:
Construct the binary tree:
Enter data for node (-1 for no node): 1
Enter left child of 1
Enter data for node (-1 for no node): 2
Enter left child of 2
Enter data for node (-1 for no node): 3
Enter left child of 3
Enter data for node (-1 for no node): 4
Enter left child of 4
Enter data for node (-1 for no node): -1
Enter right child of 4
Enter data for node (-1 for no node): -1
Enter right child of 3
Enter data for node (-1 for no node): -1
Enter right child of 2
Enter data for node (-1 for no node): -1
Enter right child of 1
Enter data for node (-1 for no node): -1

Output:
Pre-Order Traversal: 1 2 3 4

Test Case 3: Skewed Tree (Right-heavy)

Input:
Construct the binary tree:
Enter data for node (-1 for no node): 1
Enter left child of 1
Enter data for node (-1 for no node): -1
Enter right child of 1
Enter data for node (-1 for no node): 2
Enter left child of 2
Enter data for node (-1 for no node): -1
Enter right child of 2
Enter data for node (-1 for no node): 3
Enter left child of 3
Enter data for node (-1 for no node): -1
Enter right child of 3
Enter data for node (-1 for no node): 4
Enter left child of 4
Enter data for node (-1 for no node): -1
Enter right child of 4
Enter data for node (-1 for no node): -1
Output:
Pre-Order Traversal: 1 2 3 4
Lab no. 1/S.NO.3&Post-Order Traversal of a
Binary Tree
#include <stdio.h>
#include <stdlib.h>
struct Node {
int data;
struct Node* left;
struct Node* right;
};
// Function to create a new node
struct Node* createNode(int data) {
struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->data = data;
newNode->left = newNode->right = NULL;
return newNode;
}
// Function to construct the tree by taking user input
struct Node* constructTree() {
int data;
printf("Enter data for node (-1 for no node): ");
scanf("%d", &data);
// If the user enters -1, return NULL (no node)
if (data == -1)
return NULL;
struct Node* newNode = createNode(data);
printf("Enter left child of %d\n", data);
newNode->left = constructTree();
printf("Enter right child of %d\n", data);
newNode->right = constructTree();

return newNode;
}
// Function for post-order traversal
void postorderTraversal(struct Node* root) {
 if (root == NULL)
return;
postorderTraversal(root->left);
postorderTraversal(root->right);
printf("%d ", root->data);
}
int main() {
struct Node* root = NULL;
// Build the tree with user input
printf("Construct the binary tree:\n");
root = constructTree();
// Perform post-order traversal
printf("Post-Order Traversal: ");
postorderTraversal(root);
printf("\n");
return 0;
}

Test Cases for the Binary Tree Program (Post-Order Traversal)

Test Case 1:

Input:
Enter data for node (-1 for no node): 1
Enter left child of 1
Enter data for node (-1 for no node): 2
Enter left child of 2
Enter data for node (-1 for no node): 4
Enter left child of 4
Enter data for node (-1 for no node): -1
Enter right child of 4
Enter data for node (-1 for no node): -1
Enter right child of 2
Enter data for node (-1 for no node): 5
Enter left child of 5
Enter data for node (-1 for no node): -1
Enter right child of 5
Enter data for node (-1 for no node): -1
Enter right child of 1
Enter data for node (-1 for no node): 3
Enter left child of 3
Enter data for node (-1 for no node): -1
Enter right child of 3
Enter data for node (-1 for no node): -1

Output:
Post-Order Traversal: 4 5 2 3 1

Test Case 2
Input:
Enter data for node (-1 for no node): 10
Enter left child of 10
Enter data for node (-1 for no node): 20
Enter left child of 20
Enter data for node (-1 for no node): 40
Enter left child of 40
Enter data for node (-1 for no node): -1
Enter right child of 40
Enter data for node (-1 for no node): -1
Enter right child of 20
Enter data for node (-1 for no node): 50
Enter left child of 50
Enter data for node (-1 for no node): -1
Enter right child of 50
Enter data for node (-1 for no node): -1
Enter right child of 10
Enter data for node (-1 for no node): 30
Enter left child of 30
Enter data for node (-1 for no node): 60
Enter left child of 60
Enter data for node (-1 for no node): -1
Enter right child of 60
Enter data for node (-1 for no node): -1
Enter right child of 30
Enter data for node (-1 for no node): 70
Enter left child of 70
Enter data for node (-1 for no node): -1
Enter right child of 70
Enter data for node (-1 for no node): -1

Output:
Post-Order Traversal: 40 50 20 60 70 30 10

Test Case 3:
Input:
Enter data for node (-1 for no node): 5
Enter left child of 5
Enter data for node (-1 for no node): 3
Enter left child of 3
Enter data for node (-1 for no node): -1
Enter right child of 3
Enter data for node (-1 for no node): 4
Enter left child of 4
Enter data for node (-1 for no node): -1
Enter right child of 4
Enter data for node (-1 for no node): -1
Enter right child of 5
Enter data for node (-1 for no node): 8
Enter left child of 8
Enter data for node (-1 for no node): 6
Enter left child of 6
Enter data for node (-1 for no node): -1
Enter right child of 6
Enter data for node (-1 for no node): 7
Enter left child of 7
Enter data for node (-1 for no node): -1
Enter right child of 7
Enter data for node (-1 for no node): -1
Enter right child of 8
Enter data for node (-1 for no node): 9
Enter left child of 9
Enter data for node (-1 for no node): -1
Enter right child of 9
Enter data for node (-1 for no node): -1

Output:
Post-Order Traversal: 4 3 7 6 9 8 5

Lab no. 1/S.NO.4& Write a program to

implement a menu-driven program for binary
tree traversal (in-order, pre-order, post-
order) and searching.

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

// Define the structure for a node

struct Node {
 int data;
struct Node* left;
struct Node* right;
};

// Function to create a new node

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

// Function to insert a node in the binary tree

struct Node* insertNode(struct Node* root, int data) {
if (root == NULL) {
return createNode(data);
}
if (data < root->data) {
root->left = insertNode(root->left, data);
} else {
root->right = insertNode(root->right, data);
}
return root;
}

// Function for in-order traversal

void inOrder(struct Node* root) {
if (root != NULL) {
inOrder(root->left);
printf("%d ", root->data);
 inOrder(root->right);
}
}

// Function for pre-order traversal

void preOrder(struct Node* root) {
if (root != NULL) {
printf("%d ", root->data);
preOrder(root->left);
preOrder(root->right);
}
}

// Function for post-order traversal

void postOrder(struct Node* root) {
if (root != NULL) {
postOrder(root->left);
postOrder(root->right);
printf("%d ", root->data);
}
}

// Function to search for a value in the binary tree

int searchNode(struct Node* root, int key) {
if (root == NULL) {
return 0; // Key not found
}
if (root->data == key) {
return 1; // Key found
}
if (key < root->data) {
return searchNode(root->left, key);
 }
return searchNode(root->right, key);
}

// Main function
int main() {
struct Node* root = NULL;
int choice, value, searchValue;

printf("Binary Tree Menu:\n");

printf("1. Insert Node\n");
printf("2. In-order Traversal\n");
printf("3. Pre-order Traversal\n");
printf("4. Post-order Traversal\n");
printf("5. Search for a Node\n");
printf("6. Exit\n");

while (1) {
printf("\nEnter your choice: ");
scanf("%d", &choice);

switch (choice) {
case 1:
printf("Enter value to insert: ");
scanf("%d", &value);
root = insertNode(root, value);
break;

case 2:
printf("In-order Traversal: ");
inOrder(root);
printf("\n");
 break;

case 3:
printf("Pre-order Traversal: ");
preOrder(root);
printf("\n");
break;

case 4:
printf("Post-order Traversal: ");
postOrder(root);
printf("\n");
break;

case 5:
printf("Enter value to search: ");
scanf("%d", &searchValue);
if (searchNode(root, searchValue)) {
printf("Value %d found in the tree.\n", searchValue);
} else {
printf("Value %d not found in the tree.\n", searchValue);
}
break;

case 6:
printf("Exiting...\n");
exit(0);

default:
printf("Invalid choice! Please try again.\n");
}
}
 return 0;
}
Test Case 1:
Binary Tree Menu:
1. Insert Node
2. In-order Traversal
3. Pre-order Traversal
4. Post-order Traversal
5. Search for a Node
6. Exit

Enter your choice: 1

Enter value to insert: 50

Enter your choice: 1

Enter value to insert: 30

Enter your choice: 2

In-order Traversal: 30 50

Enter your choice: 5

Enter value to search: 30
Value 30 found in the tree.

Enter your choice: 6

Exiting...

Test Case 2:
Binary Tree Menu:
1. Insert Node
2. In-order Traversal
3. Pre-order Traversal
4. Post-order Traversal
5. Search for a Node
6. Exit

Enter your choice: 1

Enter value to insert: 10

Enter your choice: 1

Enter value to insert: 5

Enter your choice: 1

Enter value to insert: 15

Enter your choice: 2

In-order Traversal: 5 10 15

Enter your choice: 3

Pre-order Traversal: 10 5 15

Enter your choice: 4

Post-order Traversal: 5 15 10

Enter your choice: 5

Enter value to search: 15
Value 15 found in the tree.

Enter your choice: 6

Exiting...
Lab no. 1/S.NO.5& Count Number of Nodes in a
Binary Tree

#include <stdio.h>
#include <stdlib.h>
struct Node {
int data;
struct Node* left;
struct Node* right;
};
// Function to create a new node
struct Node* createNode(int data) {
struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->data = data;
newNode->left = newNode->right = NULL;
return newNode;
}
// Function to construct the tree by taking user input
struct Node* constructTree() {
int data;
printf("Enter data for node (-1 for no node): ");
scanf("%d", &data);
// If the user enters -1, return NULL (no node)
if (data == -1)
return NULL;
struct Node* newNode = createNode(data);
printf("Enter left child of %d\n", data);
newNode->left = constructTree();
printf("Enter right child of %d\n", data);
newNode->right = constructTree();
return newNode;
}
// Function to count the total number of nodes
int countNodes(struct Node* root) {
if (root == NULL)
return 0;
return 1 + countNodes(root->left) + countNodes(root->right);
}

int main() {
struct Node* root = NULL;
// Build the tree with user input
printf("Construct the binary tree:\n");
root = constructTree();
// Count and display the total number of nodes
printf("Total number of nodes: %d\n", countNodes(root));
return 0;
}

Test Case 1:
Input:
Enter data for node (-1 for no node): 1
Enter left child of 1
Enter data for node (-1 for no node): 2
Enter left child of 2
Enter data for node (-1 for no node): 4
Enter left child of 4
Enter data for node (-1 for no node): -1
Enter right child of 4
Enter data for node (-1 for no node): -1
Enter right child of 2
Enter data for node (-1 for no node): 5
Enter left child of 5
Enter data for node (-1 for no node): -1
Enter right child of 5
Enter data for node (-1 for no node): -1
Enter right child of 1
Enter data for node (-1 for no node): 3
Enter left child of 3
Enter data for node (-1 for no node): -1
Enter right child of 3
Enter data for node (-1 for no node): -1

Total number of nodes: 5

Test Case 2:
Input:

Enter data for node (-1 for no node): 10

Enter left child of 10
Enter data for node (-1 for no node): 20
Enter left child of 20
Enter data for node (-1 for no node): 30
Enter left child of 30
Enter data for node (-1 for no node): -1
Enter right child of 30
Enter data for node (-1 for no node): -1
Enter right child of 20
Enter data for node (-1 for no node): -1
Enter right child of 10
Enter data for node (-1 for no node): 40
Enter left child of 40
Enter data for node (-1 for no node): -1
Enter right child of 40
Enter data for node (-1 for no node): -1

Total number of nodes: 4

Test Case 3:
Input:
Enter data for node (-1 for no node): 5
Enter left child of 5
Enter data for node (-1 for no node): 8
Enter left child of 8
Enter data for node (-1 for no node): 12
Enter left child of 12
Enter data for node (-1 for no node): -1
Enter right child of 12
Enter data for node (-1 for no node): -1
Enter right child of 8
Enter data for node (-1 for no node): 15
Enter left child of 15
Enter data for node (-1 for no node): -1
Enter right child of 15
Enter data for node (-1 for no node): -1
Enter right child of 5
Enter data for node (-1 for no node): 10
Enter left child of 10
Enter data for node (-1 for no node): -1
Enter right child of 10
Enter data for node (-1 for no node): -1
Total number of nodes: 6

Lab no. 1/S.NO.6& Find the Height of a Binary

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

struct Node {
int data;
struct Node* left;
struct Node* right;
};

struct Node* createNode(int data) {

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

// Function to calculate height of the tree

int height(struct Node* root) {
if (root == NULL)
return 0;
int leftHeight = height(root->left);
int rightHeight = height(root->right);
return 1 + (leftHeight > rightHeight ? leftHeight : rightHeight);
}

// Function to insert nodes into the binary tree (creating a simple binary tree)
struct Node* insertNode(struct Node* root, int data) {
if (root == NULL) {
return createNode(data);
 }
printf("Do you want to add %d to the left (L) or right (R) of %d? ", data, root->data);
char choice;
scanf(" %c", &choice); // Space before %c to capture any leftover newline character

if (choice == 'L' || choice == 'l') {

root->left = insertNode(root->left, data);
} else if (choice == 'R' || choice == 'r') {
root->right = insertNode(root->right, data);
} else {
printf("Invalid choice! Please enter L or R.\n");
}
return root;
}

int main() {
int n, data;

// Take number of nodes in the tree as input

printf("Enter the number of nodes: ");
scanf("%d", &n);

if (n <= 0) {
printf("Invalid number of nodes.\n");
return 0;
}

printf("Enter the root node value: ");

scanf("%d", &data);

struct Node* root = createNode(data);

// Insert other nodes

for (int i = 1; i < n; i++) {
printf("Enter data for node %d: ", i+1);
scanf("%d", &data);
root = insertNode(root, data);
}

// Print the height of the tree

printf("Height of the tree: %d\n", height(root));

return 0;
}

Test case 1 :
Enter the number of nodes: 3
Enter the root node value: 1
Enter data for node 2: 2
Do you want to add 2 to the left (L) or right (R) of 1? L
Enter data for node 3: 3
Do you want to add 3 to the left (L) or right (R) of 1? R
Height of the tree: 2

Test Case 2:
Enter the number of nodes: 5
Enter the root node value: 10
Enter data for node 2: 20
Do you want to add 20 to the left (L) or right (R) of 10? L
Enter data for node 3: 30
Do you want to add 30 to the left (L) or right (R) of 20? L
Enter data for node 4: 40
Do you want to add 40 to the left (L) or right (R) of 30? L
Enter data for node 5: 50
Do you want to add 50 to the left (L) or right (R) of 40? L
Height of the tree: 5

Test Case 3:
Enter the number of nodes: 0
Invalid number of nodes.

Lab no. 1/S.NO.7& Check if a Binary Tree is

Balanced

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <math.h> // Include math.h for abs() function

struct Node {
int data;
struct Node* left;
struct Node* right;
};

struct Node* createNode(int data) {

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

int height(struct Node* root) {

if (root == NULL)
return 0;
int leftHeight = height(root->left);
int rightHeight = height(root->right);
return 1 + (leftHeight > rightHeight ? leftHeight : rightHeight);
}

bool isBalanced(struct Node* root) {

if (root == NULL)
return true;
int leftHeight = height(root->left);
int rightHeight = height(root->right);
if (abs(leftHeight - rightHeight) > 1)
return false;
return isBalanced(root->left) && isBalanced(root->right);
}

struct Node* insertNode(struct Node* root, int data) {

if (root == NULL) {
return createNode(data);
}

char choice;
printf("Do you want to add %d to the left (L) or right (R) of %d? ", data, root->data);
scanf(" %c", &choice); // Space before %c to capture any leftover newline character

if (choice == 'L' || choice == 'l') {

root->left = insertNode(root->left, data);
} else if (choice == 'R' || choice == 'r') {
root->right = insertNode(root->right, data);
} else {
printf("Invalid choice! Please enter L or R.\n");
}
return root;
}

int main() {
int i,n, data;

// Take number of nodes in the tree as input

printf("Enter the number of nodes: ");
scanf("%d", &n);
 if (n <= 0) {
printf("Invalid number of nodes.\n");
return 0;
}

printf("Enter the root node value: ");

scanf("%d", &data);
struct Node* root = createNode(data);
// Insert other nodes
for (i = 1; i < n; i++) {
printf("Enter data for node %d: ", i + 1);
scanf("%d", &data);
root = insertNode(root, data);
}
// Check if the tree is balanced
if (isBalanced(root)) {
printf("The tree is balanced.\n");
} else {
printf("The tree is not balanced.\n");
}
return 0;
}

Test Case 1:
Enter the number of nodes: 5
Enter the root node value: 1
Enter data for node 2: 2
Do you want to add 2 to the left (L) or right (R) of 1? L
Enter data for node 3: 3
Do you want to add 3 to the left (L) or right (R) of 2? R
Enter data for node 4: 4
Do you want to add 4 to the left (L) or right (R) of 3? L
Enter data for node 5: 5
Do you want to add 5 to the left (L) or right (R) of 4? R
The tree is balanced.

Test Case 2:
Enter the number of nodes: 4
Enter the root node value: 10
Enter data for node 2: 20
Do you want to add 20 to the left (L) or right (R) of 10? R
Enter data for node 3: 30
Do you want to add 30 to the left (L) or right (R) of 20? R
Enter data for node 4: 40
Do you want to add 40 to the left (L) or right (R) of 30? R
The tree is not balanced.

Test Case 3:
Enter the number of nodes: 3
Enter the root node value: 10
Enter data for node 2: 20
Do you want to add 20 to the left (L) or right (R) of 10? L
Enter data for node 3: 30
Do you want to add 30 to the left (L) or right (R) of 10? R
The tree is balanced.

Lab no. 1/S.NO.8& Search a Number in a

Binary Search Tree (BST)

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

struct Node {
int data;
struct Node* left;
struct Node* right;
};

struct Node* createNode(int data) {

struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->data = data;
newNode->left = 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;
}

int search(struct Node* root, int key) {

 if (root == NULL)
return 0;
if (root->data == key)
return 1;
if (key < root->data)
return search(root->left, key);
return search(root->right, key);
}

int main() {
struct Node* root = NULL;
int n, key;

printf("Enter number of elements to insert in BST: ");

scanf("%d", &n); // Input number of elements

printf("Enter elements:\n");
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x); // Input the elements
root = insert(root, x);
}

printf("Enter the number to search: ");

scanf("%d", &key); // Input the number to search

if (search(root, key))
printf("Number found in BST.\n");
else
printf("Number not found in BST.\n");

return 0;
}

Test Case 1:
Enter number of elements to insert in BST: 5
Enter elements:
20
10
30
5
15
Enter the number to search: 15
Number found in BST.

Test Case 2:
Enter number of elements to insert in BST: 4
Enter elements:
50
30
70
20
Enter the number to search: 60
Number not found in BST.

Test Case 3:
Enter number of elements to insert in BST: 6
Enter elements:
40
20
60
10
30
50
Enter the number to search: 30
Number found in BST.

Lab no. 1/S.NO.9& Insert a Node in a Binary

Search Tree (BST)
#include <stdio.h>
#include <stdlib.h>

struct Node {
int data;
struct Node* left;
struct Node* right;
};

struct Node* createNode(int data) {

struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->data = data;
newNode->left = 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 inorderTraversal(struct Node* root) {

if (root == NULL)
return;
inorderTraversal(root->left);
printf("%d ", root->data);
inorderTraversal(root->right);
}

int main() {
struct Node* root = NULL;
int i, n;
printf("Enter number of elements to insert in BST: ");
scanf("%d", &n);
printf("Enter elements:");
for (i = 0; i < n; i++) {
int x;
scanf("%d", &x);
root = insert(root, x);
}
printf("In-Order Traversal after insertion: ");
inorderTraversal(root);
return 0;
}

Test case 1:
Enter number of elements to insert in BST: 5
Enter elements:
30
20
40
10
25
In-Order Traversal after insertion: 10 20 25 30 40

Test Case 2:
Enter number of elements to insert in BST: 4
Enter elements:
50
30
70
60
In-Order Traversal after insertion: 30 50 60 70

Test Case 3:
Enter number of elements to insert in BST: 6
Enter elements:
15
10
20
8
12
18
In-Order Traversal after insertion: 8 10 12 15 18 20

Lab no. 1/S.NO.10. Delete a Node from a Binary Search

Tree (BST)
#include <stdio.h>
#include <stdlib.h>

struct Node {
int data;
struct Node* left;
struct Node* right;
};

struct Node* createNode(int data) {

struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->data = data;
newNode->left = 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;
}
struct Node* findMin(struct Node* root) {
while (root && root->left != NULL)
root = root->left;
return root;
}

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 = findMin(root->right);
root->data = temp->data;
root->right = deleteNode(root->right, temp->data);
}
return root;
}

void inorderTraversal(struct Node* root) {

if (root == NULL)
return;
inorderTraversal(root->left);
printf("%d ", root->data);
inorderTraversal(root->right);
}

int main() {
struct Node* root = NULL;
int i,n, key;
printf("Enter number of elements to insert in BST: ");
scanf("%d", &n);
printf("Enter elements:");
 for (i = 0; i < n; i++) {
int x;
scanf("%d", &x);
root = insert(root, x);
}
printf("Enter the number to delete: ");
scanf("%d", &key);
root = deleteNode(root, key);
printf("In-Order Traversal after deletion: ");
inorderTraversal(root);
return 0;
}

Test case1:
Enter number of elements to insert in BST: 7
Enter elements:
50 30 70 20 40 60 80
Enter the number to delete: 70
In-Order Traversal after deletion: 20 30 40 50 60 80

Test Case 2:
Enter number of elements to insert in BST: 5
Enter elements:
10 5 15 3 7
Enter the number to delete: 3
In-Order Traversal after deletion: 5 7 10 15

Test Case 3:
Enter number of elements to insert in BST: 6
Enter elements:
50 30 70 20 40 60
Enter the number to delete: 50
In-Order Traversal after deletion: 20 30 40 60 70

Lab no. 1/S.NO.11&. Implement a Max-Heap and Perform

Heap Sort on an Array of Integers
#include <stdio.h>

void swap(int* a, int* b) {

int temp = *a;
*a = *b;
*b = temp;
}
void heapify(int arr[], int n, int i) {
int largest = i;
int left = 2 * i + 1;
int right = 2 * i + 2;

if (left < n && arr[left] > arr[largest])

largest = left;
if (right < n && arr[right] > arr[largest])
largest = right;
if (largest != i) {
swap(&arr[i], &arr[largest]);
heapify(arr, n, largest);
}
}

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

int i;
for (i = n / 2 - 1; i >= 0; i--)
heapify(arr, n, i);
for (i = n - 1; i >= 0; i--) {
swap(&arr[0], &arr[i]);
heapify(arr, i, 0);
}
}

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

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

int main() {
int n,i;
printf("Enter the number of elements: ");
scanf("%d", &n);
int arr[n];
printf("Enter the elements:");
for (i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
heapSort(arr, n);
printf("Sorted array: ");
printArray(arr, n);
return 0;
}

Test Case 1:
Enter the number of elements: 6
Enter the elements: 12 11 13 5 6 7
Sorted array: 5 6 7 11 12 13

Test Case 2:
Enter the number of elements: 1
Enter the elements: 42
Sorted array: 42

Test Case 3:
Enter the number of elements: 5
Enter the elements: 9 9 9 9 9
Sorted array: 9 9 9 9 9

Lab no. 1/S.NO.12. Implement Insertion and Search

Operations in a Tree
#include <stdio.h>
#include <stdlib.h>

// Define the structure for a tree node

typedef struct Node {
int data;
struct Node *left, *right;
} Node;

// Function to create a new node

Node* createNode(int value) {
Node* newNode = (Node*)malloc(sizeof(Node));
newNode->data = value;
newNode->left = NULL;
newNode->right = NULL;
return newNode;
}

// Function to insert a node in the binary search tree

Node* insert(Node* root, int value) {
if (root == NULL) {
// If tree is empty, create a new node
return createNode(value);
}
if (value < root->data) {
 // Insert in the left subtree
root->left = insert(root->left, value);
} else if (value > root->data) {
// Insert in the right subtree
root->right = insert(root->right, value);
}
return root;
}

// Function to search for a value in the binary search tree

int search(Node* root, int value) {
if (root == NULL) {
// Value not found
return 0;
}
if (root->data == value) {
// Value found
return 1;
}
if (value < root->data) {
// Search in the left subtree
return search(root->left, value);
} else {
// Search in the right subtree
return search(root->right, value);
}
}

// Function for in-order traversal

void inOrderTraversal(Node* root) {
if (root != NULL) {
inOrderTraversal(root->left);
printf("%d ", root->data);
inOrderTraversal(root->right);
}
}

int main() {
Node* root = NULL;
int choice, value;

while (1) {
printf("\nBinary Search Tree Operations:\n");
printf("1. Insert\n");
 printf("2. Search\n");
printf("3. Display (In-order Traversal)\n");
printf("4. Exit\n");
printf("Enter your choice: ");
scanf("%d", &choice);

switch (choice) {
case 1:
printf("Enter value to insert: ");
scanf("%d", &value);
root = insert(root, value);
printf("%d inserted successfully.\n", value);
break;

case 2:
printf("Enter value to search: ");
scanf("%d", &value);
if (search(root, value)) {
printf("%d found in the tree.\n", value);
} else {
printf("%d not found in the tree.\n", value);
}
break;

case 3:
printf("In-order Traversal of the tree: ");
inOrderTraversal(root);
printf("\n");
break;

case 4:
printf("Exiting...\n");
exit(0);

default:
printf("Invalid choice! Please try again.\n");
}
}

return 0;
}

Test Case1:
Binary Search Tree Operations:
1. Insert
2. Search
3. Display (In-order Traversal)
4. Exit
Enter your choice: 1
Enter value to insert: 40

Enter your choice: 1

Enter value to insert: 20

Enter your choice: 1

Enter value to insert: 60

Enter your choice: 3

Enter your choice: 2

Enter value to search: 20

Enter your choice: 2

Enter value to search: 50

Enter your choice: 4

40 inserted successfully.
20 inserted successfully.
60 inserted successfully.
In-order Traversal of the tree: 20 40 60
20 found in the tree.
50 not found in the tree.
Exiting...

Test Case 2:

Binary Search Tree Operations:

1. Insert
2. Search
3. Display (In-order Traversal)
4. Exit
Enter your choice: 1
Enter value to insert: 1
1 inserted successfully.

Binary Search Tree Operations:

1. Insert
2. Search
3. Display (In-order Traversal)
4. Exit
Enter your choice: 1
Enter value to insert: 3
3 inserted successfully.

Binary Search Tree Operations:

1. Insert
2. Search
3. Display (In-order Traversal)
4. Exit
Enter your choice: 1
Enter value to insert: 5
5 inserted successfully.

Binary Search Tree Operations:

1. Insert
2. Search
3. Display (In-order Traversal)
4. Exit
Enter your choice: 2
Enter value to search: 1
1 found in the tree.

Binary Search Tree Operations:

1. Insert
2. Search
3. Display (In-order Traversal)
4. Exit
Enter your choice: 3
In-order Traversal of the tree: 1 3 5

Binary Search Tree Operations:

1. Insert
2. Search
3. Display (In-order Traversal)
4. Exit
Enter your choice: 4
Exiting...
Lab no. 1/S.NO.13. Write a program to calculate the
balance factor of each node of the AVL tree.

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

// Define the structure for the node

struct Node {
int data;
struct Node* left;
struct Node* right;
};

// Create a new node

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

// Insert a node into the binary tree

void insertNode(struct Node* root, int data) {
struct Node* current = root;
while (1) {
if (data < current->data) {
if (current->left == NULL) {
current->left = createNode(data);
break;
} else {
current = current->left;
}
} else {
if (current->right == NULL) {
current->right = createNode(data);
break;
} else {
current = current->right;
}
}
}
}
// Calculate the height of a subtree
int calculateHeight(struct Node* node) {
if (node == NULL)
return 0;
int leftHeight = calculateHeight(node->left);
int rightHeight = calculateHeight(node->right);
return 1 + (leftHeight > rightHeight ? leftHeight : rightHeight);
}

// Print the balance factor of each node

void printBalanceFactors(struct Node* root) {
if (root == NULL)
return;

int leftHeight = calculateHeight(root->left);

int rightHeight = calculateHeight(root->right);
int balanceFactor = leftHeight - rightHeight;

printf("Node %d: Balance Factor = %d\n", root->data, balanceFactor);

// Recur for left and right children

printBalanceFactors(root->left);
printBalanceFactors(root->right);
}

// Main function
int main() {
struct Node* root = NULL;
int choice, data;

printf("Binary Tree Creation:\n");

while (1) {
printf("\nMenu:\n");
printf("1. Insert Node\n");
printf("2. Print Balance Factors\n");
printf("3. Exit\n");
printf("Enter your choice: ");
scanf("%d", &choice);

switch (choice) {
case 1:
printf("Enter the value to insert: ");
scanf("%d", &data);
if (root == NULL) {
 root = createNode(data); // Initialize root
} else {
insertNode(root, data);
}
break;

case 2:
if (root == NULL) {
printf("Tree is empty.\n");
} else {
printf("Balance Factors of the Nodes:\n");
printBalanceFactors(root);
}
break;

case 3:
printf("Exiting...\n");
return 0;

default:
printf("Invalid choice. Try again.\n");
}
}
return 0;
}

Test Case1:
Binary Tree Creation:

Menu:
1. Insert Node
2. Print Balance Factors
3. Exit
Enter your choice: 1
Enter the value to insert: 50

Menu:
1. Insert Node
2. Print Balance Factors
3. Exit
Enter your choice: 1
Enter the value to insert: 30

Menu:
1. Insert Node
2. Print Balance Factors
3. Exit
Enter your choice: 1
Enter the value to insert: 70

Menu:
1. Insert Node
2. Print Balance Factors
3. Exit
Enter your choice: 2
Balance Factors of the Nodes:
Node 50: Balance Factor = 0
Node 30: Balance Factor = 0
Node 70: Balance Factor = 0

Test Case 2:
1. Insert Node -> 50
2. Insert Node -> 30
3. Insert Node -> 20
4. Insert Node -> 40
5. Insert Node -> 10
6. Print Balance Factors
Balance Factors of the Nodes:
Node 50: Balance Factor = 2
Node 30: Balance Factor = 1
Node 20: Balance Factor = 1
Node 40: Balance Factor = 0
Node 10: Balance Factor = 0
Lab no. 1/S.NO.14&Implement Priority Queue Using Max
Heap

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

#define MAX 1000

int heap[MAX];
int heapSize = 0;

void insert(int element) {

heap[heapSize++] = element;
int i = heapSize - 1;
while (i != 0 && heap[(i - 1) / 2] < heap[i]) {
int temp = heap[i];
heap[i] = heap[(i - 1) / 2];
heap[(i - 1) / 2] = temp;
i = (i - 1) / 2;
}
}

int extractMax() {
if (heapSize <= 0)
return -1;
if (heapSize == 1) {
heapSize--;
return heap[0];
}
int root = heap[0];
heap[0] = heap[--heapSize];
int i = 0;
while (1) {
int largest = i;
int left = 2 * i + 1;
int right = 2 * i + 2;
if (left < heapSize && heap[left] > heap[largest])
largest = left;
if (right < heapSize && heap[right] > heap[largest])
largest = right;
if (largest == i)
break;
int temp = heap[i];
heap[i] = heap[largest];
 heap[largest] = temp;
i = largest;
}
return root;
}

int main() {
int n, element;
printf("Enter the number of elements to insert: ");
scanf("%d", &n);

printf("Enter %d elements:\n", n);

for (int i = 0; i < n; i++) {
scanf("%d", &element);
insert(element);
}

printf("Extracted max: %d\n", extractMax());

printf("Extracted max: %d\n", extractMax());
return 0;
}

Test Case 1:
Enter the number of elements to insert: 5
Enter 5 elements:
10
20
15
30
25
Extracted max: 30
Extracted max: 25

Test case 2:
Enter the number of elements to insert: 3
Enter 3 elements:
5
3
8
Extracted max: 8
Extracted max: 5

Test Case 3:
Enter the number of elements to insert: 7
Enter 7 elements:
1
2
3
4
5
6
7
Extracted max: 7
Extracted max: 6

Lab no. 1/S.NO.15. Create a Graph Using an Adjacency

Matrix

#include <stdio.h>

#define MAX 10

void createGraph(int graph[MAX][MAX], int vertices) {

int i, j;
printf("\nPlease enter the adjacency matrix for the graph:\n");
for (i = 0; i < vertices; i++) {
for (j = 0; j < vertices; j++) {
printf("Enter the edge weight between vertex %d and vertex %d: ", i + 1, j + 1);
scanf("%d", &graph[i][j]);
}
}
}

void displayGraph(int graph[MAX][MAX], int vertices) {

int i, j;
printf("\nAdjacency Matrix Representation of the Graph:\n");
printf(" ");
for (i = 0; i < vertices; i++) {
printf("V%d ", i + 1); // Labeling columns with vertex numbers
}
printf("\n");

for (i = 0; i < vertices; i++) {

printf("V%d ", i + 1); // Labeling rows with vertex numbers
for (j = 0; j < vertices; j++) {
printf("%d ", graph[i][j]);
}
printf("\n");
 }
}

int main() {
int graph[MAX][MAX];
int vertices;

// Asking the user for the number of vertices in the graph

printf("Please enter the number of vertices for your graph (max %d): ", MAX);
scanf("%d", &vertices);

// Checking if the input number of vertices is within the allowed limit

if (vertices > MAX || vertices <= 0) {
printf("Invalid number of vertices. Please enter a number between 1 and %d.\n", MAX);
return 1;
}

// Creating the graph by getting the adjacency matrix

createGraph(graph, vertices);

// Displaying the adjacency matrix of the graph

displayGraph(graph, vertices);

return 0;
}

Test Case 1 :
Please enter the number of vertices for your graph (max 10): 1
Please enter the adjacency matrix for the graph:
Enter the edge weight between vertex 1 and vertex 1: 0
Adjacency Matrix Representation of the Graph:
V1
V1 0

Test Case 2:
Please enter the number of vertices for your graph (max 10): 3
Please enter the adjacency matrix for the graph:
Enter the edge weight between vertex 1 and vertex 1: 0
Enter the edge weight between vertex 1 and vertex 2: 1
Enter the edge weight between vertex 1 and vertex 3: 0
Enter the edge weight between vertex 2 and vertex 1: 1
Enter the edge weight between vertex 2 and vertex 2: 0
Enter the edge weight between vertex 2 and vertex 3: 1
Enter the edge weight between vertex 3 and vertex 1: 0
Enter the edge weight between vertex 3 and vertex 2: 1
Enter the edge weight between vertex 3 and vertex 3: 0

Adjacency Matrix Representation of the Graph:

V1 V2 V3
V1 0 1 0
V2 1 0 1
V3 0 1 0

Test case 3:
Please enter the number of vertices for your graph (max 10): 11
Invalid number of vertices. Please enter a number between 1 and 10.

Lab no. 1/S.NO.16. Create a Graph Using an Adjacency

List
#include <stdio.h>

#define MAX_VERTICES 10

// Structure for the graph using an adjacency matrix

struct Graph {
int adjMatrix[MAX_VERTICES][MAX_VERTICES];
int numVertices;
};

void initializeGraph(struct Graph *graph, int vertices) {

int i, j;
graph->numVertices = vertices;
// Initialize all entries in the adjacency matrix to 0
for (i = 0; i < vertices; i++) {
for (j = 0; j < vertices; j++) {
graph->adjMatrix[i][j] = 0;
}
}
}

void addEdge(struct Graph *graph, int src, int dest) {

// As it is an undirected graph, we mark both adjacencies
graph->adjMatrix[src][dest] = 1;
graph->adjMatrix[dest][src] = 1;
}
void printGraph(struct Graph *graph) {
int i, j;
printf("\nAdjacency Matrix:\n ");
for (i = 0; i < graph->numVertices; i++) {
printf("V%d ", i);
}
printf("\n");

for (i = 0; i < graph->numVertices; i++) {

printf("V%d ", i);
for (j = 0; j < graph->numVertices; j++) {
printf("%d ", graph->adjMatrix[i][j]);
}
printf("\n");
}
}

int main() {
struct Graph graph;
int i, vertices, edges, src, dest;

// Input for the number of vertices

printf("Enter the number of vertices (Max %d): ", MAX_VERTICES);
scanf("%d", &vertices);

if (vertices <= 0 || vertices > MAX_VERTICES) {

printf("Invalid number of vertices.\n");
return 1;
}

// Initialize the graph

initializeGraph(&graph, vertices);

// Input for the number of edges

printf("Enter the number of edges (Max %d): ", vertices * (vertices - 1) / 2);
scanf("%d", &edges);

if (edges < 0 || edges > (vertices * (vertices - 1) / 2)) {

printf("Invalid number of edges.\n");
return 1;
}

// Input for each edge

 for (i = 0; i < edges; i++) {
printf("Enter edge %d (source destination): ", i + 1);
scanf("%d %d", &src, &dest);

if (src < 0 || src >= vertices || dest < 0 || dest >= vertices) {
printf("Invalid vertices!\n");
i--; // Redo the invalid edge input
} else {
addEdge(&graph, src, dest);
}
}

// Print the adjacency matrix

printGraph(&graph);

return 0;
}

Test Case 1:
Enter the number of vertices (Max 10): 3
Enter the number of edges (Max 3): 2
Enter edge 1 (source destination): 0 1
Enter edge 2 (source destination): 1 2
Adjacency Matrix:
V0 V1 V2
V0 0 1 0
V1 1 0 1
V2 0 1 0

Test Case 2:
Enter the number of vertices (Max 10): 12
Invalid number of vertices.

Test Case 3:
Enter the number of vertices (Max 10): 4
Enter the number of edges (Max 6): -2
Invalid number of edges.

Lab no. 1/S.NO.17. Perform Depth-First Search (DFS) on a

Graph
#include <stdio.h>
#define MAX 100 // Maximum number of vertices in the graph
int graph[MAX][MAX]; // Adjacency matrix to represent the graph
int visited[MAX]; // Array to keep track of visited nodes

void dfs(int start, int vertices) {

int i;
printf("%d ", start); // Print the current vertex
visited[start] = 1; // Mark the current vertex as visited
for (i = 0; i < vertices; i++) {
if (graph[start][i] == 1 && visited[i] == 0) { // If there is an edge and the node is not visited
dfs(i, vertices); // Recursively visit the connected vertex
}
}
}

int main() {
int vertices, edges;
int v1, v2,i,j;
printf("Enter the number of vertices: ");
scanf("%d", &vertices);
printf("Enter the number of edges: ");
scanf("%d", &edges);
// Initialize the graph and visited arrays
for (i = 0; i < vertices; i++) {
for (j = 0; j < vertices; j++) {
graph[i][j] = 0;
}
visited[i] = 0;
}
printf("Enter the edges (format: v1 v2):\n");
for (i = 0; i < edges; i++) {
scanf("%d %d", &v1, &v2);
graph[v1][v2] = 1; // Mark the edge in the adjacency matrix
graph[v2][v1] = 1; // For undirected graph
}
int start;
printf("Enter the starting vertex for DFS: ");
scanf("%d", &start);
printf("DFS Traversal starting from vertex %d:\n", start);
dfs(start, vertices);
return 0;
}

Test Case 1:
Enter the number of vertices: 4
Enter the number of edges: 4
Enter the edges (format: v1 v2):
01
02
12
23
Enter the starting vertex for DFS: 0
DFS Traversal starting from vertex 0:
0123

Test Case 2
Enter the number of vertices: 6
Enter the number of edges: 4
Enter the edges (format: v1 v2):
01
02
34
45
Enter the starting vertex for DFS: 0
DFS Traversal starting from vertex 0:
012

Test Case 3
Enter the number of vertices: 1
Enter the number of edges: 0
Enter the starting vertex for DFS: 0
DFS Traversal starting from vertex 0:
0

Lab no. 1/S.NO.18. Perform Breadth-First Search (BFS) on

a Graph
#include <stdio.h>
#define MAX 100 // Maximum number of vertices in the graph

int graph[MAX][MAX]; // Adjacency matrix to represent the graph

int visited[MAX]; // Array to keep track of visited nodes
int queue[MAX]; // Queue for BFS
int front = -1, rear = -1; // Front and rear pointers for the queue

// Enqueue operation
void enqueue(int vertex) {
if (rear == MAX - 1) {
 printf("Queue overflow\n");
return;
}
if (front == -1) front = 0;
queue[++rear] = vertex;
}

// Dequeue operation
int dequeue() {
if (front == -1 || front > rear) {
printf("Queue underflow\n");
return -1;
}
return queue[front++];
}

// BFS function
void bfs(int start, int vertices) {
int i;
printf("%d ", start); // Print the starting vertex
visited[start] = 1; // Mark it as visited
enqueue(start); // Enqueue the starting vertex

while (front <= rear) {

int current = dequeue(); // Dequeue a vertex
for (i = 0; i < vertices; i++) {
if (graph[current][i] == 1 && visited[i] == 0) { // Check for unvisited neighbors
printf("%d ", i); // Print the vertex
visited[i] = 1; // Mark as visited
enqueue(i); // Enqueue the vertex
}
}
}
}

int main() {
int vertices, edges;
int v1, v2, i, j;
printf("Enter the number of vertices: ");
scanf("%d", &vertices);
printf("Enter the number of edges: ");
scanf("%d", &edges);
// Initialize the graph and visited arrays
for (i = 0; i < vertices; i++) {
 for (j = 0; j < vertices; j++) {
graph[i][j] = 0;
}
visited[i] = 0;
}
printf("Enter the edges (format: v1 v2):\n");
for (i = 0; i < edges; i++) {
scanf("%d %d", &v1 &v2);
graph[v1][v2] = 1; // Mark the edge in the adjacency matrix
graph[v2][v1] = 1; // For undirected graph
}
int start;
printf("Enter the starting vertex for BFS: ");
scanf("%d", &start);
printf("BFS Traversal starting from vertex %d:\n", start);
bfs(start, vertices);
return 0;
}

Test Case 1:

Enter the number of vertices: 4

Enter the number of edges: 4
Enter the edges (format: v1 v2):
01
02
12
23
Enter the starting vertex for BFS: 0
BFS Traversal starting from vertex 0:
0123

Test Case 2:
Enter the number of vertices: 6
Enter the number of edges: 4
Enter the edges (format: v1 v2):
01
02
34
45
Enter the starting vertex for BFS: 0
BFS Traversal starting from vertex 0:
012
Test Case 3:
Enter the number of vertices: 1
Enter the number of edges: 0
Enter the starting vertex for BFS: 0
BFS Traversal starting from vertex 0:
0

Lab no. 1/S.NO.19. Check if There is a Path Between Two

Nodes in a Graph Using DFS
Description: This program demonstrates 17. check if there is a path between two nodes in a
graph using dfs. Below is the C implementation.

#include <stdio.h>
#include <stdbool.h>
#define MAX 100

int graph[MAX][MAX];
int visited[MAX];

bool DFS(int current, int destination, int vertices) {

int i;
if (current == destination)
return true;
visited[current] = 1;
for (i = 0; i < vertices; i++) {
if (graph[current][i] && !visited[i]) {
if (DFS(i, destination, vertices))
return true;
}
}
return false;
}

int main() {
int vertices, edges, i, j, src, dest, addEdge;

printf("Enter number of vertices (Max %d): ", MAX);

scanf("%d", &vertices);

if (vertices <= 0 || vertices > MAX) {

printf("Invalid number of vertices. Exiting...\n");
return 1;
}
 // Initialize the graph with no edges
for (i = 0; i < vertices; i++) {
for (j = 0; j < vertices; j++) {
graph[i][j] = 0;
}
}

printf("You can add edges between nodes from 0 to %d.\n", vertices - 1);

// Ask user to add edges

for (src = 0; src < vertices; src++) {
for (dest = src + 1; dest < vertices; dest++) {
printf("Do you want to add an edge between node %d and node %d? (1 for Yes, 0 for
No): ", src, dest);
scanf("%d", &addEdge);

if (addEdge == 1) {
graph[src][dest] = 1;
graph[dest][src] = 1; // Undirected graph
printf("Edge added between node %d and node %d.\n", src, dest);
}
}
}

printf("Enter source and destination nodes to check for a path (0 to %d): ", vertices - 1);
scanf("%d %d", &src, &dest);

// Check if the source and destination nodes are valid

if (src < 0 || src >= vertices || dest < 0 || dest >= vertices) {
printf("Invalid source or destination node.\n");
return 1;
}

// Initialize visited array

for (i = 0; i < vertices; i++) {
visited[i] = 0;
}

// Perform DFS to check for path

if (DFS(src, dest, vertices)) {
printf("Path exists between node %d and node %d.\n", src, dest);
} else {
printf("No path exists between node %d and node %d.\n", src, dest);
 }

return 0;
}

Test Case 1:
Enter number of vertices (Max 100): 3
You can add edges between nodes from 0 to 2.
Do you want to add an edge between node 0 and node 1? (1 for Yes, 0 for No): 1
Edge added between node 0 and node 1.
Do you want to add an edge between node 0 and node 2? (1 for Yes, 0 for No): 0
Do you want to add an edge between node 1 and node 2? (1 for Yes, 0 for No): 0
Enter source and destination nodes to check for a path (0 to 2): 0 2
No path exists between node 0 and node 2.

Test Case 2:
Enter number of vertices (Max 100): 4
You can add edges between nodes from 0 to 3.
Do you want to add an edge between node 0 and node 1? (1 for Yes, 0 for No): 1
Edge added between node 0 and node 1.
Do you want to add an edge between node 0 and node 2? (1 for Yes, 0 for No): 1
Edge added between node 0 and node 2.
Do you want to add an edge between node 1 and node 2? (1 for Yes, 0 for No): 0
Do you want to add an edge between node 1 and node 3? (1 for Yes, 0 for No): 1
Edge added between node 1 and node 3.
Do you want to add an edge between node 2 and node 3? (1 for Yes, 0 for No): 0
Enter source and destination nodes to check for a path (0 to 3): 0 3
Path exists between node 0 and node 3.

Test Case 3:
Enter number of vertices (Max 100): 5
You can add edges between nodes from 0 to 4.
Do you want to add an edge between node 0 and node 1? (1 for Yes, 0 for No): 1
Edge added between node 0 and node 1.
Do you want to add an edge between node 0 and node 2? (1 for Yes, 0 for No): 1
Edge added between node 0 and node 2.
Do you want to add an edge between node 1 and node 2? (1 for Yes, 0 for No): 0
Do you want to add an edge between node 1 and node 3? (1 for Yes, 0 for No): 1
Edge added between node 1 and node 3.
Do you want to add an edge between node 1 and node 4? (1 for Yes, 0 for No): 0
Do you want to add an edge between node 2 and node 3? (1 for Yes, 0 for No): 1
Edge added between node 2 and node 3.
Do you want to add an edge between node 2 and node 4? (1 for Yes, 0 for No): 1
Edge added between node 2 and node 4.
Do you want to add an edge between node 3 and node 4? (1 for Yes, 0 for No): 0
Enter source and destination nodes to check for a path (0 to 4): 0 4
Path exists between node 0 and node 4.

Lab no. 1/S.NO.20. Find All Vertices Reachable from a

Given Vertex in a Graph Using BFS

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

#define MAX 100

int graph[MAX][MAX];
int visited[MAX];

void BFS(int start, int vertices) {

int queue[MAX], i, front = 0, rear = 0;
printf("Reachable vertices from %d: ", start);
visited[start] = 1;
queue[rear++] = start;

while (front < rear) {

int vertex = queue[front++];
for (i = 0; i < vertices; i++) {
if (graph[vertex][i] && !visited[i]) {
printf("%d ", i);
visited[i] = 1;
queue[rear++] = i;
}
}
}
printf("\n");
}

int main() {
int vertices, i, j, edges = 0, src, dest, start;
int addEdge;

// User input for vertices

printf("Enter number of vertices (Max %d): ", MAX);
scanf("%d", &vertices);
 if (vertices <= 0 || vertices > MAX) {
printf("Invalid number of vertices. Exiting...\n");
return 1;
}

// Initialize the graph with no edges

for (i = 0; i < vertices; i++) {
for (j = 0; j < vertices; j++) {
graph[i][j] = 0;
}
}

printf("You can add edges between nodes from 0 to %d.\n", vertices - 1);

// Ask user to add edges between pairs of nodes

for (i = 0; i < vertices; i++) {
for (j = i + 1; j < vertices; j++) { // Only need to ask once for each pair (i, j)
printf("Do you want to add an edge between node %d and node %d? (1 for yes, 0 for
no): ", i, j);
scanf("%d", &addEdge);

if (addEdge == 1) {
// Add the edge to the graph
graph[i][j] = 1;
graph[j][i] = 1; // Undirected graph
printf("Edge added between node %d and node %d.\n", i, j);
edges++;
} else {
printf("No edge added between node %d and node %d.\n", i, j);
}
}
}

printf("You have added %d edges in total.\n", edges);

// User input for starting vertex

printf("Enter the starting vertex (0 to %d): ", vertices - 1);
scanf("%d", &start);

// Validate the starting vertex

if (start < 0 || start >= vertices) {
printf("Invalid starting vertex. Exiting...\n");
return 1;
 }

// Initialize visited array

for (i = 0; i < vertices; i++) {
visited[i] = 0;
}

// Perform BFS to find reachable vertices

BFS(start, vertices);

return 0;
}

Test Case 1:
Enter number of vertices (Max 100): 3
You can add edges between nodes from 0 to 2.
Do you want to add an edge between node 0 and node 1? (1 for yes, 0 for no): 1
Edge added between node 0 and node 1.
Do you want to add an edge between node 0 and node 2? (1 for yes, 0 for no): 1
Edge added between node 0 and node 2.
Do you want to add an edge between node 1 and node 2? (1 for yes, 0 for no): 1
Edge added between node 1 and node 2.
You have added 3 edges in total.
Enter the starting vertex (0 to 2): 0
Reachable vertices from 0: 0 1 2

Test Case 2:
Enter number of vertices (Max 100): 4
You can add edges between nodes from 0 to 3.
Do you want to add an edge between node 0 and node 1? (1 for yes, 0 for no): 1
Edge added between node 0 and node 1.
Do you want to add an edge between node 0 and node 2? (1 for yes, 0 for no): 0
No edge added between node 0 and node 2.
Do you want to add an edge between node 0 and node 3? (1 for yes, 0 for no): 0
No edge added between node 0 and node 3.
Do you want to add an edge between node 1 and node 2? (1 for yes, 0 for no): 0
No edge added between node 1 and node 2.
Do you want to add an edge between node 1 and node 3? (1 for yes, 0 for no): 0
No edge added between node 1 and node 3.
Do you want to add an edge between node 2 and node 3? (1 for yes, 0 for no): 1
Edge added between node 2 and node 3.
You have added 2 edges in total.
Enter the starting vertex (0 to 3): 0
Reachable vertices from 0: 0 1

Test Case 3:
Enter number of vertices (Max 100): 5
You can add edges between nodes from 0 to 4.
Do you want to add an edge between node 0 and node 1? (1 for yes, 0 for no): 1
Edge added between node 0 and node 1.
Do you want to add an edge between node 0 and node 2? (1 for yes, 0 for no): 0
No edge added between node 0 and node 2.
Do you want to add an edge between node 0 and node 3? (1 for yes, 0 for no): 0
No edge added between node 0 and node 3.
Do you want to add an edge between node 0 and node 4? (1 for yes, 0 for no): 0
No edge added between node 0 and node 4.
Do you want to add an edge between node 1 and node 2? (1 for yes, 0 for no): 1
Edge added between node 1 and node 2.
Do you want to add an edge between node 1 and node 3? (1 for yes, 0 for no): 0
No edge added between node 1 and node 3.
Do you want to add an edge between node 1 and node 4? (1 for yes, 0 for no): 0
No edge added between node 1 and node 4.
Do you want to add an edge between node 2 and node 3? (1 for yes, 0 for no): 1
Edge added between node 2 and node 3.
Do you want to add an edge between node 2 and node 4? (1 for yes, 0 for no): 0
No edge added between node 2 and node 4.
Do you want to add an edge between node 3 and node 4? (1 for yes, 0 for no): 0
No edge added between node 3 and node 4.
You have added 3 edges in total.
Enter the starting vertex (0 to 4): 0
Reachable vertices from 0: 0 1 2

Lab no. 1/S.NO.21. Detect a Cycle in an Undirected Graph

Using DFS
Description: This program demonstrates 19. detect a cycle in an undirected graph using dfs.
Below is the C implementation.

#include <stdio.h>
#include <stdbool.h>

#define MAX 100

int graph[MAX][MAX];
int visited[MAX];

bool detectCycleDFS(int vertex, int parent, int vertices) {

 visited[vertex] = 1;
for (int i = 0; i < vertices; i++) {
if (graph[vertex][i]) {
if (!visited[i]) {
if (detectCycleDFS(i, vertex, vertices))
return true;
} else if (i != parent) {
return true;
}
}
}
return false;
}

int main() {
int vertices, edges, src, dest;
printf("Enter number of vertices and edges: ");
scanf("%d %d", &vertices, &edges);
printf("Enter edges (src dest):");
for (int i = 0; i < edges; i++) {
scanf("%d %d", &src, &dest);
graph[src][dest] = 1;
graph[dest][src] = 1; // Undirected graph
}
if (detectCycleDFS(0, -1, vertices))
printf("Cycle detected in the graph.");
else
printf("No cycle detected in the graph.");
return 0;
}

Lab no. 1/S.NO.22. Detect a Cycle in a Directed Graph

Using DFS
Description: This program demonstrates 20. detect a cycle in a directed graph using dfs. Below
is the C implementation.

#include <stdio.h>
#include <stdbool.h>

#define MAX 100

// Function to perform DFS and check for a cycle

bool dfs(int graph[MAX][MAX], int visited[], int recursionStack[], int node, int vertices) {
int neighbor;
visited[node] = 1;
recursionStack[node] = 1;

for (neighbor = 0; neighbor < vertices; neighbor++) {

if (graph[node][neighbor]) { // Check if there's an edge
if (!visited[neighbor]) {
if (dfs(graph, visited, recursionStack, neighbor, vertices)) {
return true; // Cycle detected
}
} else if (recursionStack[neighbor]) {
return true; // Cycle detected
}
}
}

recursionStack[node] = 0; // Remove from recursion stack

return false;
}

// Function to check for a cycle in the graph

bool isCyclic(int graph[MAX][MAX], int vertices) {
int i ;
int visited[MAX] = {0};
int recursionStack[MAX] = {0};

for (i = 0; i < vertices; i++) {

if (!visited[i]) {
if (dfs(graph, visited, recursionStack, i, vertices)) {
return true; // Cycle detected
}
}
}
return false; // No cycle detected
}

int main() {
int i;
int vertices, edges;
printf("Enter the number of vertices: ");
scanf("%d", &vertices);

int graph[MAX][MAX] = {0};

 printf("Enter the number of edges: ");
scanf("%d", &edges);

printf("Enter the edges (start end):\n");

for (i = 0; i < edges; i++) {
int start, end;
scanf("%d %d", &start, &end);
graph[start][end] = 1;
}

if (isCyclic(graph, vertices)) {
printf("The graph contains a cycle.\n");
} else {
printf("The graph does not contain a cycle.\n");
}

return 0;
}

Test Case1:

Enter the number of vertices: 4

Enter the number of edges: 4
Enter the edges (start end):
01
12
23
31
The graph contains a cycle.

Test Case 2:
Enter the number of vertices: 4
Enter the number of edges: 3
Enter the edges (start end):
01
12
23
The graph does not contain a cycle.
Lab no. 1/S.NO.23.. Find the Degree of Each Vertex in an
Undirected Graph
Description: This program demonstrates 21. find the degree of each vertex in an undirected
graph. Below is the C implementation.

#include <stdio.h>

#define MAX 100

int main() {
int graph[MAX][MAX] = {0};
int vertices, edges;

// Input the number of vertices

printf("Enter the number of vertices: ");
scanf("%d", &vertices);

// Input the number of edges

printf("Enter the number of edges: ");
scanf("%d", &edges);

// Input the edges

printf("Enter the edges (start end):\n");
for (int i = 0; i < edges; i++) {
int start, end;
scanf("%d %d", &start, &end);

// Since the graph is undirected, mark both directions

graph[start][end] = 1;
graph[end][start] = 1;
}

// Calculate and print the degree of each vertex

printf("Degree of each vertex:\n");
for (int i = 0; i < vertices; i++) {
int degree = 0;
for (int j = 0; j < vertices; j++) {
if (graph[i][j] == 1) {
degree++;
}
 }
printf("Vertex %d: Degree %d\n", i, degree);
}

return 0;
}

Test Case1:
Enter the number of vertices: 4
Enter the number of edges: 4
Enter the edges (start end):
01
02
12
23
Degree of each vertex:
Vertex 0: Degree 2
Vertex 1: Degree 2
Vertex 2: Degree 3
Vertex 3: Degree 1

Test Case 2:
Enter the number of vertices: 3
Enter the number of edges: 2
Enter the edges (start end):
01
12
Degree of each vertex:
Vertex 0: Degree 1
Vertex 1: Degree 2
Vertex 2: Degree 1
Lab no. 1/S.NO.24. Count the Number of Connected
Components in an Undirected Graph
#include <stdio.h>
#include <stdbool.h>
#define MAX 100
// Function to perform DFS
void dfs(int graph[MAX][MAX], bool visited[], int vertex, int vertices) {
visited[vertex] = true;
for (int i = 0; i < vertices; i++) {
if (graph[vertex][i] == 1 && !visited[i]) {
dfs(graph, visited, i, vertices);
}
}
}
// Function to count connected components
int countConnectedComponents(int graph[MAX][MAX], int vertices) {
bool visited[MAX] = {false};
int count = 0;
for (int i = 0; i < vertices; i++) {
if (!visited[i]) {
dfs(graph, visited, i, vertices);
count++;
}
}
return count;
}
int main() {
int graph[MAX][MAX] = {0};
int vertices, edges;
// Input the number of vertices
printf("Enter the number of vertices: ");
scanf("%d", &vertices);
// Input the number of edges
printf("Enter the number of edges: ");
scanf("%d", &edges);
// Input the edges
printf("Enter the edges (start end):\n");
for (int i = 0; i < edges; i++) {
int start, end;
scanf("%d %d", &start, &end);
// Since the graph is undirected, mark both directions
graph[start][end] = 1;
graph[end][start] = 1; }
 // Count and display the number of connected components
int result = countConnectedComponents(graph, vertices);
printf("The number of connected components in the graph is: %d\n", result);

return 0;
}

Test Case 1:
Enter the number of vertices: 6
Enter the number of edges: 3
Enter the edges (start end):
01
23
45
The number of connected components in the graph is: 3

Test Case2:
Enter the number of vertices: 4
Enter the number of edges: 2
Enter the edges (start end):
01
23
The number of connected components in the graph is: 2

Lab no. 1/S.NO.25. Implement Dijkstra's

Algorithm
#include <stdio.h>
#include <limits.h>
#include <stdbool.h>

#define MAX 100

// Function to find the vertex with the minimum distance value

int findMinDistance(int dist[], bool visited[], int vertices) {
int min = INT_MAX, minIndex;
int v;
for (v = 0; v < vertices; v++) {
if (!visited[v] && dist[v] <= min) {
min = dist[v];
minIndex = v;
}
 }
return minIndex;
}

// Function to implement Dijkstra's algorithm

void dijkstra(int graph[MAX][MAX], int vertices, int startVertex) {
int dist[MAX]; // Array to store the shortest distances
bool visited[MAX]; // Array to track visited vertices
int u,v,i,count;
// Initialize distances to infinity and visited array to false
for (i = 0; i < vertices; i++) {
dist[i] = INT_MAX;
visited[i] = false;
}

dist[startVertex] = 0; // Distance from source to itself is always 0

// Find shortest path for all vertices

for (count = 0; count < vertices - 1; count++) {
u = findMinDistance(dist, visited, vertices); // Pick the minimum distance vertex
visited[u] = true;

// Update distances of adjacent vertices

for (v = 0; v < vertices; v++) {
if (!visited[v] && graph[u][v] && dist[u] != INT_MAX
&& dist[u] + graph[u][v] < dist[v]) {
dist[v] = dist[u] + graph[u][v];
}
}
}

// Print the shortest distances

printf("Vertex\tDistance from Source\n");
for (i = 0; i < vertices; i++) {
printf("%d\t%d\n", i, dist[i]);
}
}

int main() {
int graph[MAX][MAX], vertices, edges;
int i,j;
// Input the number of vertices
printf("Enter the number of vertices: ");
scanf("%d", &vertices);
 // Input the number of edges
printf("Enter the number of edges: ");
scanf("%d", &edges);

// Initialize the graph with 0s

for (i = 0; i < vertices; i++) {
for (j = 0; j < vertices; j++) {
graph[i][j] = 0;
}
}

// Input the edges and weights

printf("Enter the edges with weights (start end weight):\n");
for (i = 0; i < edges; i++) {
int start, end, weight;
scanf("%d %d %d", &start, &end, &weight);
graph[start][end] = weight;
graph[end][start] = weight; // For undirected graph
}

int startVertex;
printf("Enter the starting vertex: ");
scanf("%d", &startVertex);

// Perform Dijkstra's Algorithm

dijkstra(graph, vertices, startVertex);

return 0;
}

Test Case 1:
Enter the number of vertices: 5
Enter the number of edges: 6
Enter the edges with weights (start end weight):
012
024
121
137
243
341
Enter the starting vertex: 0
Vertex Distance from Source
0 0
1 2
2 3
3 9
4 6

Test Case 2
Enter the number of vertices: 4
Enter the number of edges: 4
Enter the edges with weights (start end weight):
015
0 2 10
122
133
Enter the starting vertex: 0
Vertex Distance from Source
0 0
1 5
2 7
3 8

Lab no. 1/S.NO.26. Implement Prim's

Algorithm
#include <limits.h>
#include <stdbool.h>
#include <stdio.h>

#define MAX 100

// Function to find the vertex with the minimum weight

int minweight(int weight[], bool visited[], int V)
{
int min = INT_MAX, min_index;

for (int v = 0; v < V; v++) {

if (visited[v] == false && weight[v] < min) {
min = weight[v];
min_index = v;
}
}
return min_index;
}

// Function to print the constructed MST and its total cost

void printMST(int parent[], int graph[MAX][MAX], int V)
{
int totalCost = 0;

printf("MST for the graph:\n");

printf("Edge \tWeight\n");
for (int i = 1; i < V; i++) {
printf("%d - %d \t%d \n", parent[i], i, graph[i][parent[i]]);
totalCost += graph[i][parent[i]];
}
printf("Total cost of MST: %d\n", totalCost);
}

// Function to construct and print MST for a graph

void primMST(int graph[MAX][MAX], int V)
{
int parent[MAX]; // Array to store constructed MST
int weight[MAX]; // Array to store the weights
bool visited[MAX]; // To represent set of vertices included in MST

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

weight[i] = INT_MAX;
visited[i] = false;
}

weight[0] = 0;
parent[0] = -1;

for (int count = 0; count < V - 1; count++) {

int u = minweight(weight, visited, V);

visited[u] = true;

for (int v = 0; v < V; v++) {

if (graph[u][v] && !visited[v] && graph[u][v] < weight[v]) {
parent[v] = u;
weight[v] = graph[u][v];
}
}
}

printMST(parent, graph, V);

}
int main()
{
int V;
int graph[MAX][MAX];

printf("Enter the number of vertices: ");

scanf("%d", &V);

printf("Enter the adjacency matrix of the graph (use 0 for no direct edge):\n");
for (int i = 0; i < V; i++) {
for (int j = 0; j < V; j++) {
printf("Edge weight between vertex %d and %d: ", i, j);
scanf("%d", &graph[i][j]);
}
}

primMST(graph, V);

return 0;
}

Enter the number of vertices: 5

Enter the adjacency matrix of the graph (use 0 for no direct edge):
Edge weight between vertex 0 and 0: 0
Edge weight between vertex 0 and 1: 2
Edge weight between vertex 0 and 2: 0
Edge weight between vertex 0 and 3: 6
Edge weight between vertex 0 and 4: 0
Edge weight between vertex 1 and 0: 2
Edge weight between vertex 1 and 1: 0
Edge weight between vertex 1 and 2: 3
Edge weight between vertex 1 and 3: 8
Edge weight between vertex 1 and 4: 5
Edge weight between vertex 2 and 0: 0
Edge weight between vertex 2 and 1: 3
Edge weight between vertex 2 and 2: 0
Edge weight between vertex 2 and 3: 0
Edge weight between vertex 2 and 4: 7
Edge weight between vertex 3 and 0: 6
Edge weight between vertex 3 and 1: 8
Edge weight between vertex 3 and 2: 0
Edge weight between vertex 3 and 3: 0
Edge weight between vertex 3 and 4: 9
Edge weight between vertex 4 and 0: 0
Edge weight between vertex 4 and 1: 5
Edge weight between vertex 4 and 2: 7
Edge weight between vertex 4 and 3: 9
Edge weight between vertex 4 and 4: 0

MST for the graph:

Edge Weight
0-1 2
1-2 3
0-3 6
1-4 5
Total cost of MST: 16

Test Case 2 :

Enter the number of vertices: 4

Enter the adjacency matrix of the graph (use 0 for no direct edge):
Edge weight between vertex 0 and 0: 0
Edge weight between vertex 0 and 1: 10
Edge weight between vertex 0 and 2: 6
Edge weight between vertex 0 and 3: 5
Edge weight between vertex 1 and 0: 10
Edge weight between vertex 1 and 1: 0
Edge weight between vertex 1 and 2: 15
Edge weight between vertex 1 and 3: 0
Edge weight between vertex 2 and 0: 6
Edge weight between vertex 2 and 1: 15
Edge weight between vertex 2 and 2: 0
Edge weight between vertex 2 and 3: 4
Edge weight between vertex 3 and 0: 5
Edge weight between vertex 3 and 1: 0
Edge weight between vertex 3 and 2: 4
Edge weight between vertex 3 and 3: 0

MST for the graph:

Edge Weight
3-2 4
3-0 5
0 - 1 10
Total cost of MST: 19
Lab no. 1/S.NO.27. Implement Kruskal's Algorithm
#include <stdio.h>
#include <stdlib.h>

#define MAX 100

// Structure to represent an edge

typedef struct {
int source, destination, weight;
} Edge;

// Structure to represent a graph

typedef struct {
int V, E; // Number of vertices and edges
Edge edges[MAX];
} Graph;

// Structure to represent a subset for union-find

typedef struct {
int parent, rank;
} Subset;

// Function to compare two edges by their weights

int compareEdges(const void* a, const void* b) {
Edge* edgeA = (Edge*)a;
Edge* edgeB = (Edge*)b;
return edgeA->weight - edgeB->weight;
}

// Function to find the subset of an element (using path compression)

int find(Subset subsets[], int i) {
if (subsets[i].parent != i)
subsets[i].parent = find(subsets, subsets[i].parent);
return subsets[i].parent;
}

// Function to unite two subsets (union by rank)

void unionSubsets(Subset subsets[], int x, int y) {
int rootX = find(subsets, x);
int rootY = find(subsets, y);

if (subsets[rootX].rank < subsets[rootY].rank) {

subsets[rootX].parent = rootY;
 } else if (subsets[rootX].rank > subsets[rootY].rank) {
subsets[rootY].parent = rootX;
} else {
subsets[rootY].parent = rootX;
subsets[rootX].rank++;
}
}

// Function to find MST using Kruskal's Algorithm

void kruskalMST(Graph* graph) {
int V = graph->V;
Edge result[MAX]; // To store the resulting MST
int e = 0; // Index for result[]
int i = 0; // Index for sorted edges

// Step 1: Sort all edges by weight

qsort(graph->edges, graph->E, sizeof(graph->edges[0]), compareEdges);

// Allocate memory for creating subsets

Subset* subsets = (Subset*)malloc(V * sizeof(Subset));

for (int v = 0; v < V; ++v) {

subsets[v].parent = v;
subsets[v].rank = 0;
}

// Iterate through sorted edges and build MST

while (e < V - 1 && i < graph->E) {
Edge nextEdge = graph->edges[i++];

int x = find(subsets, nextEdge.source);

int y = find(subsets, nextEdge.destination);

// If including this edge doesn't form a cycle

if (x != y) {
result[e++] = nextEdge;
unionSubsets(subsets, x, y);
}
}

// Print the MST and its total cost

int totalCost = 0;
printf("MST for the graph:\n");
printf("Edge \tWeight\n");
 for (int j = 0; j < e; ++j) {
printf("%d - %d \t%d\n", result[j].source, result[j].destination, result[j].weight);
totalCost += result[j].weight;
}
printf("Total cost of MST: %d\n", totalCost);

// Free allocated memory

free(subsets);
}

int main() {
Graph graph;
printf("Enter the number of vertices: ");
scanf("%d", &graph.V);

printf("Enter the number of edges: ");

scanf("%d", &graph.E);

printf("Enter the edges (source, destination, weight):\n");

for (int i = 0; i < graph.E; i++) {
printf("Edge %d: ", i + 1);
scanf("%d %d %d", &graph.edges[i].source, &graph.edges[i].destination,
&graph.edges[i].weight);
}
kruskalMST(&graph);
return 0;
}
Test Case 1:
Enter the number of vertices: 4
Enter the number of edges: 5
Enter the edges (source, destination, weight):
Edge 1: 0 1 10
Edge 2: 0 2 6
Edge 3: 0 3 5
Edge 4: 1 3 15
Edge 5: 2 3 4
MST for the graph:
Edge Weight
2-3 4
0-3 5
0 - 1 10
Total cost of MST: 19
Test Case 2:
Enter the number of vertices: 4
Enter the edges (source, destination, weight):
MST for the graph:
Edge Weight
Total cost of MST: 0

Lab no. 1/S.NO.28. Implement Floyd-Warshall's All Pair

Shortest Path Algorithm
#include <stdio.h>

// Define the number of vertices as a maximum value

#define MAX 100

// Define Infinite as a large value for unreachable paths

#define INF 99999

// A function to print the solution matrix

void printSolution(int dist[][MAX], int V);

// Solves the all-pairs shortest path problem using Floyd Warshall algorithm
void floydWarshall(int dist[][MAX], int V)
{
int i, j, k;

// Add all vertices to the set of intermediate vertices

for (k = 0; k < V; k++) {
// Pick all vertices as source one by one
for (i = 0; i < V; i++) {
// Pick all vertices as destination for the above picked source
for (j = 0; j < V; j++) {
// If vertex k is on the shortest path from i to j, update the value of dist[i][j]
if (dist[i][k] + dist[k][j] < dist[i][j]) {
dist[i][j] = dist[i][k] + dist[k][j];
}
}
}
}

// Print the shortest distance matrix

printSolution(dist, V);
}

// A utility function to print the solution

void printSolution(int dist[][MAX], int V)
{
printf("The following matrix shows the shortest distances between every pair of vertices:\n");
for (int i = 0; i < V; i++) {
for (int j = 0; j < V; j++) {
if (dist[i][j] == INF)
printf("%7s", "INF");
else
printf("%7d", dist[i][j]);
}
printf("\n");
}
}

// Driver code
int main()
{
int V, E;
int graph[MAX][MAX];

printf("Enter the number of vertices: ");

scanf("%d", &V);

// Initialize the graph with INF (no direct connection)

for (int i = 0; i < V; i++) {
for (int j = 0; j < V; j++) {
if (i == j)
graph[i][j] = 0; // Distance to self is 0
else
graph[i][j] = INF; // Initialize all other distances to INF
}
}

printf("Enter the number of edges: ");

scanf("%d", &E);

printf("Enter the edges (source, destination, weight):\n");

for (int i = 0; i < E; i++) {
int u, v, w;
printf("Edge %d: ", i + 1);
scanf("%d %d %d", &u, &v, &w);
graph[u][v] = w; // Directed graph
}

// Perform Floyd Warshall algorithm

 floydWarshall(graph, V);

return 0;
}

Test Case 1 :
Enter the number of vertices: 4
Enter the number of edges: 4
Enter the edges (source, destination, weight):
Edge 1: 0 1 5
Edge 2: 0 2 10
Edge 3: 1 3 15
Edge 4: 2 3 20

The following matrix shows the shortest distances between every pair of vertices:
0 5 10 20
INF 0 INF 15
INF INF 0 20
INF INF INF 0

Test Case 2
Enter the number of vertices: 5
Enter the number of edges: 6
Enter the edges (source, destination, weight):
Edge 1: 0 1 2
Edge 2: 1 2 3
Edge 3: 0 3 8
Edge 4: 3 4 1
Edge 5: 4 1 7
Edge 6: 2 4 5

The following matrix shows the shortest distances between every pair of vertices:
0 2 5 8 9
INF 0 3 INF 8
INF INF 0 INF 5
INF 9 12 0 1
INF 7 10 INF 0
Lab no. 1/S.NO.29. Implement Bellman-Ford Algorithm
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>

// Define maximum number of vertices

#define MAX_VERTICES 1000
// Define infinity for initialization
#define INF INT_MAX

// Define Bellman-Ford function

void bellmanFord(int graph[][3], int vertices, int edges, int source) {
// Declare distance array
int distance[MAX_VERTICES];

// Initialize distances from source to all vertices as infinity

for (int i = 0; i < vertices; ++i)
distance[i] = INF;
// Distance from source to itself is 0
distance[source] = 0;

// Relax edges V-1 times

for (int i = 0; i < vertices - 1; ++i) {
for (int j = 0; j < edges; ++j) {
if (distance[graph[j][0]] != INF &&
distance[graph[j][1]] > distance[graph[j][0]] + graph[j][2]) {
distance[graph[j][1]] = distance[graph[j][0]] + graph[j][2];
}
}
}

// Check for negative cycles

for (int i = 0; i < edges; ++i) {
if (distance[graph[i][0]] != INF &&
distance[graph[i][1]] > distance[graph[i][0]] + graph[i][2]) {
printf("Negative cycle detected\n");
return;
}
}

// Print shortest distances from source to all vertices

printf("Vertex Distance from Source\n");
for (int i = 0; i < vertices; ++i) {
 if (distance[i] == INF)
printf("%d \t\t INF\n", i);
else
printf("%d \t\t %d\n", i, distance[i]);
}
}

// Define main function

int main() {
int vertices, edges, source;

// Input number of vertices and edges

printf("Enter the number of vertices: ");
scanf("%d", &vertices);
printf("Enter the number of edges: ");
scanf("%d", &edges);

// Input the edges of the graph

int graph[MAX_VERTICES][3];
printf("Enter the edges (source destination weight):\n");
for (int i = 0; i < edges; ++i) {
printf("Edge %d: ", i + 1);
scanf("%d %d %d", &graph[i][0], &graph[i][1], &graph[i][2]);
}

// Input the source vertex

printf("Enter the source vertex: ");
scanf("%d", &source);
// Call Bellman-Ford function
bellmanFord(graph, vertices, edges, source);
return 0;
}

Test case 1:

Enter the number of vertices: 4

Enter the number of edges: 5
Enter the edges (source destination weight):
Edge 1: 0 1 4
Edge 2: 0 2 5
Edge 3: 1 2 -3
Edge 4: 1 3 6
Edge 5: 2 3 2
Enter the source vertex: 0
Vertex Distance from Source
0 0
1 4
2 1
3 3

Test Case 2:

Enter the number of vertices: 3

Enter the number of edges: 3
Enter the edges (source destination weight):
Edge 1: 0 1 1
Edge 2: 1 2 -1
Edge 3: 2 0 -1
Enter the source vertex: 0

Negative cycle detected

Lab no. 1/S.NO.30. Implement Longest Common
Subsequence (LCS)
#include <stdio.h>
#include <string.h>

// Function to return the maximum of two integers

int max(int a, int b) {
return (a > b) ? a : b;
}

// Function to find the length of the Longest Common Subsequence (LCS) using recursion
int lcsRecursive(char* X, char* Y, int m, int n) {
// Base case: If either string is empty, LCS length is 0
if (m == 0 || n == 0)
return 0;

// If the characters match, include them in LCS and recur for the remaining strings
if (X[m - 1] == Y[n - 1])
return 1 + lcsRecursive(X, Y, m - 1, n - 1);

// If the characters do not match, recursively find LCS by excluding one character at a time
else
return max(lcsRecursive(X, Y, m, n - 1), lcsRecursive(X, Y, m - 1, n));
}

int main() {
// Define variables for input strings
char X[100], Y[100];

// Input first string

printf("Enter the first string: ");
scanf("%s", X);

// Input second string

printf("Enter the second string: ");
scanf("%s", Y);

// Length of first string

int m = strlen(X);
// Length of second string
int n = strlen(Y);

// Calculate and print the length of Longest Common Subsequence (LCS)

 printf("Length of LCS is %d\n", lcsRecursive(X, Y, m, n));

return 0;
}

Test Case 1:
Enter the first string: ABCD
Enter the second string: ACBD
Length of LCS is 3

Test Case 2:
Enter the first string: XYZ
Enter the second string: YZXY
Length of LCS is 2

Lab no. 1/S.NO.31. Implement Sum of Subset Problem

Using Backtracking
#include <stdio.h>
#include <stdbool.h>

// Flag to check if at least one subset exists

bool flag = false;

// Function to print all subsets with sum equal to targetSum

void PrintSubsetSum(int i, int n, int set[], int targetSum, int subset[], int subsetSize) {
// If targetSum is 0, print the subset
int j;
if (targetSum == 0) {
flag = true;
printf("[ ");
for (j = 0; j < subsetSize; j++) {
printf("%d ", subset[j]);
}
printf("]\n");
return;
}

// If end of the set is reached, return

if (i == n) {
return;
}
 // Exclude the current element and move to the next
PrintSubsetSum(i + 1, n, set, targetSum, subset, subsetSize);

// Include the current element if it is less than or equal to targetSum

if (set[i] <= targetSum) {
subset[subsetSize] = set[i];
PrintSubsetSum(i + 1, n, set, targetSum - set[i], subset, subsetSize + 1);
}
}

// Driver code
int main() {
int n, sum;

// Input the size of the set

printf("Enter the number of elements in the set: ");
scanf("%d", &n);

int set[n];
int subset[n],i; // Array to hold the subset

// Input the elements of the set

printf("Enter the elements of the set: ");
for (i = 0; i < n; i++) {
scanf("%d", &set[i]);
}

// Input the target sum

printf("Enter the target sum: ");
scanf("%d", &sum);

// Call the function to print subsets

printf("Subsets with sum %d:\n", sum);
PrintSubsetSum(0, n, set, sum, subset, 0);

if (!flag) {
printf("There is no such subset\n");
}

return 0;
}

Test Case 1:
Enter the number of elements in the set: 3
Enter the elements of the set: 1 2 1
Enter the target sum: 3
Subsets with sum 3:
[12]
[21]
[111]

Test Case 2:
Enter the number of elements in the set: 6
Enter the elements of the set: 3 34 4 12 5 2
Enter the target sum: 30
Subsets with sum 30:
There is no such subset