J.C.

BOSE UNIVERSITY OF
SCIENCE & TECHNOLOGY,
YMCA

DEPARTMENT OF COMPUTER
APPLICATIONS
MCA (2024-26)
2nd SEMESTER

A.D.A Project File

Submitted to : Submitted by:

Chirag Anand

Dr. Lalit Mohan 24001602011

 INDEX
Sr.No. Experiments Date Signature

1. Program to perform Selection Sort.

2. Program to perform Insertion Sort.

3. Program to perform merge Sort.

4. Program to perform quick sort

5. Program to perform heap Sort.

6. Program to perform BFS Traversal.
7. Program to perform DFS Traversal.

8. Program to perform Krushkal Algorithm.

9. Program to perform Knapsack problem.

10. Program to perform Travelling Salesman

Problem.
11. Program to perform Binary Search Tree.

12. Program to perform Min- Max Algorithm

13. Program to perform 8 Queen Problem

14. Program to perform Sum of sumset

1. Selection Sort
Description: This program sorts an array in ascending order using the selection sort algorithm, where the
minimum element is selected and swapped.
```cpp
#include <iostream>
using namespace std;

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

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

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

for (int i = 0; i < n; i++) {
cout << arr[i] << " ";
}
cout << endl;
}

int main() {
int n;
cout << "Enter the size of array: ";
cin >> n;
int arr[n];
cout << "Enter " << n << " elements: ";
for (int i = 0; i < n; i++)
cin >> arr[i];
cout << "Original array: ";
printArray(arr, n);
selectionSort(arr, n);

cout << "Sorted array: ";

printArray(arr, n);
return 0;
}
```
 Sample Input:
Enter the size of array: 5
Enter 5 elements: 64 34 25 12 22
Sample Output:
Original array: 64 34 25 12 22
Sorted array: 12 22 25 34 64
Explanation: Minimum element is found and placed at the beginning in each pass.

2. Insertion Sort
Description: This program sorts an array in ascending order using insertion sort, inserting elements into the
sorted portion.
```cpp
#include <iostream>
using namespace std;

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

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

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

for (int i = 0; i < n; i++) {
cout << arr[i] << " ";
}
cout << endl;
}

int main() {
int n;
cout << "Enter the size of array: ";
cin >> n;
int arr[n];
cout << "Enter " << n << " elements: ";
for (int i = 0; i < n; i++)
cin >> arr[i];
cout << "Original array: ";
printArray(arr, n);
insertionSort(arr, n);
cout << "Sorted array: ";
printArray(arr, n);
 return 0;
}
```
Sample Input:
Enter the size of array: 5
Enter 5 elements: 64 34 25 12 22
Sample Output:
Original array: 64 34 25 12 22
Sorted array: 12 22 25 34 64
Explanation: Each element is inserted into its correct position in the sorted portion.

3. Merge Sort
Description: This program sorts an array using merge sort, dividing into halves, sorting, and merging.
```cpp
#include <iostream>
using namespace std;

void merge(int arr[], int left, int mid, int right) {

int n1 = mid - left + 1;
int n2 = right - mid;
int leftArr[n1], rightArr[n2];
for (int i = 0; i < n1; i++) leftArr[i] = arr[left + i];
for (int j = 0; j < n2; j++) rightArr[j] = arr[mid + 1 + j];
int i = 0, j = 0, k = left;
while (i < n1 && j < n2) {
if (leftArr[i] <= rightArr[j]) {
arr[k] = leftArr[i];
i++;
} else {
arr[k] = rightArr[j];
j++;
}
k++;
}
while (i < n1) {
arr[k] = leftArr[i];
i++;
k++;
}
while (j < n2) {
arr[k] = rightArr[j];
j++;
k++;
}
}

void mergeSort(int arr[], int left, int right) {

 if (left < right) {
int mid = left + (right - left) / 2;
mergeSort(arr, left, mid);
mergeSort(arr, mid + 1, right);
merge(arr, left, mid, right);
}
}

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

for (int i = 0; i < n; i++) {
cout << arr[i] << " ";
}
cout << endl;
}

int main() {
int n;
cout << "Enter the size of array: ";
cin >> n;
int arr[n];
cout << "Enter " << n << " elements: ";
for (int i = 0; i < n; i++)
cin >> arr[i];
cout << "Original array: ";
printArray(arr, n);
mergeSort(arr, 0, n - 1);
cout << "Sorted array: ";
printArray(arr, n);
return 0;
}
```
Sample Input:
Enter the size of array: 5
Enter 5 elements: 64 34 25 12 22
Sample Output:
Original array: 64 34 25 12 22
Sorted array: 12 22 25 34 64
Explanation: Array is divided, sorted, and merged back.

4. Quick Sort
Description: This program sorts an array using quick sort with a pivot-based partition.
```cpp
#include <iostream>
using namespace std;

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

int temp = a;
 a = b;
b = temp;
}

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

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

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

if (low < high) {
int pi = partition(arr, low, high);
quickSort(arr, low, pi - 1);
quickSort(arr, pi + 1, high);
}
}

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

for (int i = 0; i < n; i++) {
cout << arr[i] << " ";
}
cout << endl;
}

int main() {
int n;
cout << "Enter the size of array: ";
cin >> n;
int arr[n];
cout << "Enter " << n << " elements: ";
for (int i = 0; i < n; i++)
cin >> arr[i];
cout << "Original array: ";
printArray(arr, n);
quickSort(arr, 0, n - 1);
cout << "Sorted array: ";
printArray(arr, n);
return 0;
}
```
Sample Input:
Enter the size of array: 5
Enter 5 elements: 64 34 25 12 22
Sample Output:
Original array: 64 34 25 12 22
Sorted array: 12 22 25 34 64
Explanation: Pivot partitions the array, and subarrays are sorted recursively.

5. Heap Sort
Description: This program sorts an array using heap sort with a max heap.
```cpp
#include <iostream>
using namespace std;

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) {

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

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

for (int i = 0; i < n; i++) {
cout << arr[i] << " ";
}
cout << endl;
}

int main() {
int n;
cout << "Enter the size of array: ";
cin >> n;
 int arr[n];

cout << "Enter " << n << " elements: ";

for (int i = 0; i < n; i++)
cin >> arr[i];
cout << "Original array: ";
printArray(arr, n);
heapSort(arr, n);
cout << "Sorted array: ";
printArray(arr, n);
return 0;
}
```
Sample Input:
Enter the size of array: 5
Enter 5 elements: 64 34 25 12 22
Sample Output:
Original array: 64 34 25 12 22
Sorted array: 12 22 25 34 64
Explanation: Max heap is built, and maximum elements are extracted.

6. BFS Traversal
Description: This program performs BFS on a graph using an adjacency matrix.
```cpp
#include <iostream>
#include <queue>
using namespace std;

#define MAX 100

void BFS(int graph[MAX][MAX], int start, int n) {

bool visited[MAX] = {false};
queue<int> q;
visited[start] = true;
q.push(start);
while (!q.empty()) {
int current = q.front();
cout << current << " ";
q.pop();
for (int i = 0; i < n; i++) {
if (graph[current][i] == 1 && !visited[i]) {
visited[i] = true;
q.push(i);
}
}
}
}
int main() {
int n;
cout << "Enter the number of vertices: ";
cin >> n;
int graph[MAX][MAX] = {0};
cout << "Enter the adjacency matrix (1 for edge, 0 for no edge):\n";
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
cin >> graph[i][j];
int start;
cout << "Enter the starting vertex: ";
cin >> start;
cout << "BFS Traversal starting from vertex " << start << ": ";
BFS(graph, start, n);
cout << endl;
return 0;
}
```
Sample Input:
Enter the number of vertices: 4
Enter the adjacency matrix (1 for edge, 0 for no edge):
0110
1001
1001
0110
Enter the starting vertex: 0
Sample Output:
BFS Traversal starting from vertex 0: 0 1 2 3
Explanation: Visits nodes level by level.

7. DFS Traversal
Description: This program performs DFS on a graph using an adjacency matrix.
```cpp
#include <iostream>
using namespace std;

#define MAX 100

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

visited[vertex] = true;
cout << vertex << " ";
for (int i = 0; i < n; i++) {
if (graph[vertex][i] == 1 && !visited[i]) {
DFS(graph, i, n, visited);
}
 }
}

int main() {
int n;
cout << "Enter the number of vertices: ";
cin >> n;
int graph[MAX][MAX] = {0};
cout << "Enter the adjacency matrix (1 for edge, 0 for no edge):\n";
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
cin >> graph[i][j];
int start;
cout << "Enter the starting vertex: ";
cin >> start;
bool visited[MAX] = {false};
cout << "DFS Traversal starting from vertex " << start << ": ";
DFS(graph, start, n, visited);
cout << endl;
return 0;
}
```
Sample Input:
Enter the number of vertices: 4
Enter the adjacency matrix (1 for edge, 0 for no edge):
0110
1001
1001
0110
Enter the starting vertex: 0
Sample Output:
DFS Traversal starting from vertex 0: 0 1 3 2
Explanation: Goes deep into one path before backtracking.

8. Kruskal's Algorithm
Description: This program finds the minimum spanning tree using Kruskal's algorithm.
```cpp
#include <iostream>
using namespace std;

#define MAX 100

struct Edge {
int src, dest, weight;
};

struct Graph {
 int V, E;

Edge* edge;
};

int find(int parent[], int i) {

if (parent[i] == -1) return i;
return find(parent, parent[i]);
}

void Union(int parent[], int x, int y) {

parent[x] = y;
}

void KruskalMST(Graph* graph) {

int V = graph->V;
Edge result[V];
int e = 0, i = 0;
for (int a = 0; a < V - 1; a++) {
for (int b = 0; b < V - a - 1; b++) {
if (graph->edge[b].weight > graph->edge[b + 1].weight) {
swap(graph->edge[b], graph->edge[b + 1]);
}
}
}
int parent[V];
for (int i = 0; i < V; i++) parent[i] = -1;
while (e < V - 1 && i < graph->E) {
int x = find(parent, graph->edge[i].src);
int y = find(parent, graph->edge[i].dest);
if (x != y) {
result[e++] = graph->edge[i];
Union(parent, x, y);
}
i++;
}
cout << "Edges in the Minimum Spanning Tree:\n";
for (i = 0; i < e; i++) {
cout << result[i].src << " -- " << result[i].dest << " : " << result[i].weight << endl;
}
}

int main() {
int V, E;
cout << "Enter number of vertices: ";
cin >> V;
cout << "Enter number of edges: ";
 cin >> E;
Graph* graph = new Graph();
graph->V = V;
graph->E = E;
graph->edge = new Edge[E];
cout << "Enter " << E << " edges (source destination weight):\n";
for (int i = 0; i < E; i++) {
cin >> graph->edge[i].src >> graph->edge[i].dest >> graph->edge[i].weight;
}
KruskalMST(graph);
delete graph->edge;
delete graph;
return 0;
}
```
Sample Input:
Enter number of vertices: 4
Enter number of edges: 5
Enter 5 edges (source destination weight):
0 1 10
026
035
1 3 15
234
Sample Output:
Edges in the Minimum Spanning Tree:
2 -- 3 : 4
0 -- 3 : 5
0 -- 1 : 10
Explanation: MST with total weight 19.

9. Knapsack Problem
Description: This program solves the 0/1 Knapsack problem using dynamic programming.
```cpp
#include <iostream>
using namespace std;

// Function to solve Knapsack problem

int knapsack(int values[], int weights[], int n, int capacity) {
int dp[n + 1][capacity + 1];
for (int i = 0; i <= n; i++) {
for (int w = 0; w <= capacity; w++) {
if (i == 0 || w == 0)
dp[i][w] = 0;
else if (weights[i - 1] <= w)
dp[i][w] = max(values[i - 1] + dp[i - 1][w - weights[i - 1]], dp[i - 1][w]);
else
 dp[i][w] = dp[i - 1][w];
}
}
return dp[n][capacity];
}

int main() {
int n, capacity;
cout << "Enter number of items: ";
cin >> n;
cout << "Enter knapsack capacity: ";
cin >> capacity;
int values[n], weights[n];
for (int i = 0; i < n; i++) {
cout << "Enter value for item " << i + 1 << ": ";
cin >> values[i];
cout << "Enter weight for item " << i + 1 << ": ";
cin >> weights[i];
}
int maxValue = knapsack(values, weights, n, capacity);
cout << "Maximum value that can be achieved: " << maxValue << endl;
return 0;
}
```
Sample Input:
Enter number of items: 3
Enter knapsack capacity: 50
Enter value for item 1: 60
Enter weight for item 1: 10
Enter value for item 2: 100
Enter weight for item 2: 20
Enter value for item 3: 120
Enter weight for item 3: 30
Sample Output:
Maximum value that can be achieved: 220
Explanation: Selects items 2 and 3 (100 + 120) within capacity.

10. Travelling Salesman Problem

Description: This program finds the shortest route visiting all cities using brute force.
```cpp
#include <iostream>
#include <limits.h>
using namespace std;

int tsp(int graph[][10], int n, int visited[], int currPos, int count, int cost, int &answer) {
if (count == n && graph[currPos][0]) {
answer = min(answer, cost + graph[currPos][0]);
 return answer;
}
for (int i = 0; i < n; i++) {
if (visited[i] == 0 && graph[currPos][i]) {
visited[i] = 1;
tsp(graph, n, visited, i, count + 1, cost + graph[currPos][i], answer);
visited[i] = 0;
}
}
return answer;
}

int main() {
int n;
cout << "Enter number of cities: ";
cin >> n;
int graph[10][10];
cout << "Enter the distance matrix (0 if no direct path):\n";
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
cin >> graph[i][j];
int visited[10] = {0};
visited[0] = 1;
int answer = INT_MAX;
tsp(graph, n, visited, 0, 1, 0, answer);
cout << "Minimum cost for TSP: " << answer << endl;
return 0;
}
```
Sample Input:
Enter number of cities: 4
Enter the distance matrix (0 if no direct path):
0 10 15 20
10 0 35 25
15 35 0 30
20 25 30 0
Sample Output:
Minimum cost for TSP: 80
Explanation: Shortest path (e.g., 0->1->3->2->0) totals 80.

11. Binary Search Tree

Description: This program creates a BST and performs inorder traversal.
```cpp
// program to perform the insertion and deletion in the binary search tree with inorder preorderand postorder
of the tree .
#include <iostream>
using namespace std;
// node class for the bst
class node{
public:
int data;
node* left;
node* right;
node(int val){
data = val;
left= NULL;
right = NULL;

}
};

// function to insert the value in a bst

node* insert(node* root , int value ){
if(root == NULL){
return new node(value);
}
if(value < root->data){
root->left = insert(root->left, value);
}else if(value > root->data){
root->right =insert(root->right, value);
}
return root;
}

// function to find the minimum value of the root for the

node* findMin(node* root){
node* current = root;
while( current && current->left != NULL){
current = current->left;
}
return current;
}

// function to delete a node from the BST

node* deletenode(node* root , int value){
if(root == NULL ){
return NULL;
}
if(value < root->data){
root->left = deletenode(root->left,value);
}else if(value > root->data){
root->right= deletenode(root->right,value);
}
 else{
// no child or a one child
if(root->left == NULL){
node* temp = root->right;
delete root;
return temp;
}
else if(root->right == NULL){
node* temp = root->left;
delete root;
return temp;
}
// case 2 if two children
node* temp = findMin(root->right);
root->data = temp->data;
root->right = deletenode(root->right, temp->data);
}
return root;

}
// function to search the element in the BST
node* search(node* root , int value){
if(root == NULL || root->data == value){
return root;
}
else if(value < root->data ){
return search(root->left,value);

}
return search(root->right , value);
}

// in order traversal (left- root - right )

void inorder(node* root){
if(root != NULL){
inorder(root->left);
cout<< root->data << " ";
inorder(root->right);
}
}

// preorder traversal of the (root, left,right)

void preorder(node* root){
if(root != NULL){
cout << root->data << " ";
preorder(root->left);
preorder(root->right);
 }
}
void postorder(node* root){
if(root != NULL){
postorder(root->left);
postorder(root->right);
cout << root->data << " ";
}
}

int main() {
node* root = NULL;

// Insert some values

root = insert(root, 50);
insert(root, 30);
insert(root, 70);
insert(root, 20);
insert(root, 40);
insert(root, 60);
insert(root, 80);

cout << "Inorder traversal: ";

inorder(root);
cout << endl;

cout << "Preorder traversal: ";

preorder(root);
cout << endl;

cout << "Postorder traversal: ";

postorder(root);
cout << endl;

// Search for a value

int key = 40;
if (search(root, key)) {
cout << key << " found in the BST!" << endl;
} else {
cout << key << " not found in the BST!" << endl;
}

// Delete a value
root = deletenode(root, 30);
cout << "Inorder after deleting 30: ";
inorder(root);
cout << endl;
 return 0;
}
```
Output:
Inorder traversal: 20 30 40 50 60 70 80
Preorder traversal: 50 30 20 40 70 60 80
Postorder traversal: 20 40 30 60 80 70 50
40 found in the BST!
Inorder after deleting 30: 20 40 50 60 70 80
12. Min Max
Description: This program finds the minimum and maximum values in an array.
#include <iostream>
#include <utility> // pair ke liye
using namespace std;

// Function to find min and max, tera approach follow kiya

pair<int, int> min_max_algo(int arr[], int n) {
if (n <= 0) {
return {0, 0}; // Edge case: empty array
}

int min = arr[0]; // Initial min

int max = arr[0]; // Initial max (tera arr[1] wala idea safe nahi tha)

int min_temp, max_temp; // Temporary variables jo tune use kiye the

// Odd length array

if (n % 2 != 0) {
for (int i = 1; i <= n - 2; i += 2) { // i+1 out of bounds na jaye isliye n-2
if (arr[i] < arr[i + 1]) {
min_temp = arr[i];
max_temp = arr[i + 1];
} else {
min_temp = arr[i + 1];
max_temp = arr[i];
}
if (min_temp < min) {
min = min_temp;
}
if (max_temp > max) {
max = max_temp;
}
}
// Last element ko handle karna (odd case mein)
if (arr[n - 1] < min) min = arr[n - 1];
if (arr[n - 1] > max) max = arr[n - 1];
 }
// Even length array
else {
for (int i = 0; i <= n - 2; i += 2) { // i+1 safe rahe isliye n-2
if (arr[i] < arr[i + 1]) {
min_temp = arr[i];
max_temp = arr[i + 1];
} else {
min_temp = arr[i + 1];
max_temp = arr[i];
}
if (min_temp < min) {
min = min_temp;
}
if (max_temp > max) {
max = max_temp;
}
}
}

return {min, max}; // Min aur max dono return karne ke liye pair
}

// Main function to test

int main() {
int arr[] = {15, 34, 20, 06, 78, 12, 9,21,100};
int n = sizeof(arr) / sizeof(arr[0]);

pair<int, int> result = min_max_algo(arr, n);

cout << "Minimum: " << result.first << endl;
cout << "Maximum: " << result.second << endl;

return 0;
} ```
Output:
Minimum: 6
Maximum: 100

13. 8-Queen
**Description:** This program places 8 queens on an 8x8 chessboard with no threats.
```cpp
#include <iostream>
using namespace std;

#define N 8

bool isSafe(int board[N][N], int row, int col) {

 for (int i = 0; i < col; i++) if (board[row][i]) return false;
for (int i = row, j = col; i >= 0 && j >= 0; i--, j--) if (board[i][j]) return false;
for (int i = row, j = col; i < N && j >= 0; i++, j--) if (board[i][j]) return false;
return true;
}

bool solveNQueen(int board[N][N], int col) {

if (col >= N) return true;
for (int i = 0; i < N; i++) {
if (isSafe(board, i, col)) {
board[i][col] = 1;
if (solveNQueen(board, col + 1)) return true;
board[i][col] = 0;
}
}
return false;
}

void printBoard(int board[N][N]) {

for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++)
cout << board[i][j] << " ";
cout << endl;
}
}

int main() {
int board[N][N] = {0};
if (solveNQueen(board, 0)) {
cout << "Solution for 8 Queen Problem:\n";
printBoard(board);
} else {
cout << "No solution exists\n";
}
return 0;
}
```
Output :
00100000
10000000
00001000
00000010
00000100
01000000
00010000
00000001
Explanation: One valid placement with no conflicts.
14. Sum of Subset
**Description:** This program finds subsets with a given sum using brute force.
```cpp
#include <iostream>
using namespace std;

// Function to check if there's a subset with the given sum

bool isSubsetSum(int arr[], int n, int target) {
// Base Cases
if (target == 0) return true; // Subset found
if (n == 0) return false; // No elements left

// If current element is greater than target, skip it

if (arr[n - 1] > target)
return isSubsetSum(arr, n - 1, target);

// Check including OR excluding the current element

return isSubsetSum(arr, n - 1, target) ||
isSubsetSum(arr, n - 1, target - arr[n - 1]);
}

int main() {
int arr[] = {3, 34, 4, 12, 5, 2};
int n = sizeof(arr) / sizeof(arr[0]);
int target;

cout << "Enter target sum: ";

cin >> target;

if (isSubsetSum(arr, n, target))
cout << "Subset with given sum exists." << endl;
else
cout << "No subset with given sum." << endl;

return 0;
}
```
Output :
Enter target sum: 15
Subset with given sum exists.