Experiment No: 1
Aim: write a program of Linear search by using recursion .
Program:
#include <stdio.h>
int linearSearch(int arr[], int size, int key, int index) {
if (index >= size) {
return -1; // Base case: key not found
if (arr[index] == key) {
return index; // Base case: key found
return linearSearch(arr, size, key, index + 1);
int main() {
int n, key;
printf("Enter the number of elements in the array: ");
scanf("%d", &n);
int arr[n];
printf("Enter %d elements of the array: \n", n);
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
printf("Enter the element to search for: ");
scanf("%d", &key)
int result = linearSearch(arr, n, key, 0);
if (result != -1) {
printf("Element %d found at index %d.\n", key, result);
} else {
printf("Element %d not found in the array.\n", key);
return 0;
Output:
Enter the number of elements in the array: 5
Enter 5 elements of the array:
10 20 30 40 50
Enter the element to search for: 30
Element 30 found at index 2.
Experiment No: 2
Aim: Write a Program to perform Binary Search for a given set of integer values recursively
Program:
#include <stdio.h>
int binarySearch(int arr[], int low, int high, int key) {
if (low > high) {
return -1;
}
int mid = low + (high - low) / 2;
if (arr[mid] == key) {
return mid; // Element found
} else if (arr[mid] > key) {
return binarySearch(arr, low, mid - 1, key);
} else {
return binarySearch(arr, mid + 1, high, key);
int main() {
int n, key;
printf("Enter the number of elements in the array: ");
scanf("%d", &n);
int arr[n];
printf("Enter %d sorted elements: \n", n);
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
printf("Enter the element to search: ");
scanf("%d", &key);
int result = binarySearch(arr, 0, n - 1, key);
if (result != -1) {
printf("Element %d found at index %d.\n", key, result);
} else {
printf("Element %d not found in the array.\n", key);
return 0;
OUTPUT:
Enter the number of elements in the array: 5
Enter 5 sorted elements:
13579
Enter the element to search: 7
Element 7 found at index 3.
Experiment No: 3
Aim: Write a program to perform Quick Sort for the given list of integer values
Program:
#include <stdio.h>
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 size) {
for (int i = 0; i < size; i++) {
printf("%d ", arr[i]);
printf("\n");
int main() {
int arr[] = {10, 7, 8, 9, 1, 5};
int n = sizeof(arr) / sizeof(arr[0]);
printf("Original array: \n");
printArray(arr, n);
quickSort(arr, 0, n - 1);
printf("\nSorted array: \n");
printArray(arr, n);
return 0;
OUTPUT:
If the input array is {10, 7, 8, 9, 1, 5}, the program prints:
Original array:
10 7 8 9 1 5
Sorted array:
1 5 7 8 9 10
Experiment No: 4
Aim: Write a program to perform Merge sort for any given list of numbers.
Program:
#include <stdio.h>
void merge(int arr[], int left, int mid, int right) {
int n1 = mid - left + 1;
int n2 = right - mid;
int L[n1], R[n2];
for (int i = 0; i < n1; i++)
L[i] = arr[left + i];
for (int j = 0; j < n2; j++)
R[j] = arr[mid + 1 + j];
int i = 0, j = 0, k = left;
while (i < n1 && j < n2) {
if (L[i] <= R[j]) {
arr[k] = L[i];
i++;
} else {
arr[k] = R[j];
j++;
k++;
while (i < n1) {
arr[k] = L[i];
i++;
k++;
while (j < n2) {
arr[k] = R[j];
j++;
k++;
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 size) {
for (int i = 0; i < size; i++)
printf("%d ", arr[i]);
printf("\n");
int main() {
int arr[] = {38, 27, 43, 3, 9, 82, 10};
int size = sizeof(arr) / sizeof(arr[0]);
printf("Original array: \n");
printArray(arr, size);
mergeSort(arr, 0, size - 1);
printf("\nSorted array: \n");
printArray(arr, size);
return 0;
OUTPUT:
Input:
Original array:
38 27 43 3 9 82 10
Output:
Sorted array:
3 9 10 27 38 43 82
Experiment No: 5
Aim: Write a program to perform Heap sort for any given list of numbers.
Program:
#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) {
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++) {
printf("%d ", arr[i]);
printf("\n");
int main() {
int arr[] = {12, 11, 13, 5, 6, 7};
int n = sizeof(arr) / sizeof(arr[0]);
printf("Original array: \n");
printArray(arr, n);
heapSort(arr, n);
printf("\nSorted array: \n");
printArray(arr, n);
return 0;
OUTPUT:
Original array:
12 11 13 5 6 7
Sorted array:
5 6 7 11 12 13
Experiment No: 6
Aim: Write a program to find solution for knapsack problem using greedy method
Program:
#include <stdio.h>
struct Item {
int weight;
int value;
double ratio;
};
int compare(const void *a, const void *b) {
struct Item *item1 = (struct Item *)a;
struct Item *item2 = (struct Item *)b;
if (item1->ratio > item2->ratio) return -1;
if (item1->ratio < item2->ratio) return 1;
return 0;
double knapsack(struct Item items[], int n, int capacity) {
qsort(items, n, sizeof(struct Item), compare);
double totalValue = 0.0;
int currentWeight = 0;
for (int i = 0; i < n; i++) {
if (currentWeight + items[i].weight <= capacity) {
currentWeight += items[i].weight;
totalValue += items[i].value;
} else {
int remainingCapacity = capacity - currentWeight;
totalValue += items[i].value * ((double)remainingCapacity / items[i].weight);
break;
}
return totalValue;
int main() {
int n = 4;
struct Item items[] = {
{10, 60, 0.0}, // {weight, value, ratio}
{20, 100, 0.0},
{30, 120, 0.0},
{5, 50, 0.0}
};
for (int i = 0; i < n; i++) {
items[i].ratio = (double)items[i].value / items[i].weight;
int capacity = 50;
double maxValue = knapsack(items, n, capacity);
printf("Maximum value in knapsack = %.2f\n", maxValue);
return 0;
OUTPUT:
Input:
Items: {weight = 10, value = 60}, {weight = 20, value = 100}, {weight = 30,
value = 120}, {weight = 5, value = 50}
Knapsack capacity: 50
Output:
Maximum value in knapsack: 240.00
Experiment No: 7
Aim: Write a program to find minimum cost spanning tree using Prim’s Algorithm..
Program:
#include <stdio.h>
#include <limits.h>
#define MAX 100
int findMinKeyVertex(int key[], int included[], int vertices) {
int min = INT_MAX, minIndex;
for (int v = 0; v < vertices; v++) {
if (!included[v] && key[v] < min) {
min = key[v];
minIndex = v;
}
return minIndex;
void printMST(int parent[], int graph[MAX][MAX], int vertices) {
printf("Edge \tWeight\n");
for (int i = 1; i < vertices; i++) {
printf("%d - %d \t%d\n", parent[i], i, graph[i][parent[i]]);
void primMST(int graph[MAX][MAX], int vertices) {
int parent[MAX];
int key[MAX];
int included[MAX];
for (int i = 0; i < vertices; i++) {
key[i] = INT_MAX;
included[i] = 0;
}
key[0] = 0;
parent[0] = -1;
for (int count = 0; count < vertices - 1; count++) {
int u = findMinKeyVertex(key, included, vertices);
included[u] = 1;
for (int v = 0; v < vertices; v++) {
if (graph[u][v] && !included[v] && graph[u][v] < key[v]) {
parent[v] = u;
key[v] = graph[u][v];
printMST(parent, graph, vertices);
int main() {
int vertices;
int graph[MAX][MAX];
printf("Enter the number of vertices: ");
scanf("%d", &vertices);
printf("Enter the adjacency matrix (use 0 for no edge):\n");
for (int i = 0; i < vertices; i++) {
for (int j = 0; j < vertices; j++) {
scanf("%d", &graph[i][j]);
primMST(graph, vertices);
return 0;
OUTPUT:
Enter the number of vertices: 4
Enter the adjacency matrix (use 0 for no edge):
0206
2038
0300
6800
OUTPUT:
Edge Weight
0-1 2
1-2 3
0-3 6
Experiment No: 8
Aim:. Write a C program implementing Dijkstra's Algorithm
Program:
#include <stdio.h>
#include <limits.h>
int minDistance(int dist[], int sptSet[]) {
int min = INT_MAX, min_index;
for (int v = 0; v < V; v++) {
if (sptSet[v] == 0 && dist[v] <= min) {
min = dist[v];
min_index = v;
return min_index;
void dijkstra(int graph[V][V], int src) {
int dist[V]; // The shortest distance from source to each vertex
int sptSet[V]; // sptSet[i] will be true if vertex i is included in the shortest path tree
for (int i = 0; i < V; i++) {
dist[i] = INT_MAX;
sptSet[i] = 0;
dist[src] = 0;
for (int count = 0; count < V - 1; count++) {
int u = minDistance(dist, sptSet);
sptSet[u] = 1;
for (int v = 0; v < V; v++) {
if (!sptSet[v] && graph[u][v] && dist[u] != INT_MAX && dist[u] + graph[u][v] < dist[v]) {
dist[v] = dist[u] + graph[u][v];
printf("Vertex \t Distance from Source\n");
for (int i = 0; i < V; i++) {
printf("%d \t %d\n", i, dist[i]);
int main() {
int graph[V][V] = {
{0, 4, 0, 0, 0, 0, 0, 8, 0},
{4, 0, 8, 0, 0, 0, 0, 11, 0},
{0, 8, 0, 7, 0, 4, 0, 0, 2},
{0, 0, 7, 0, 9, 14, 0, 0, 0},
{0, 0, 0, 9, 0, 10, 0, 0, 0},
{0, 0, 4, 14, 10, 0, 2, 0, 0},
{0, 0, 0, 0, 0, 2, 0, 1, 6},
{8, 11, 0, 0, 0, 0, 1, 0, 7},
{0, 0, 2, 0, 0, 0, 6, 7, 0}
};
int source = 0;
dijkstra(graph, source);
return 0;
OUTPUT:
Vertex Distance from Source
0 0
1 4
2 12
3 19
4 21
5 11
6 9
7 8
Experiment No: 9
Aim: Write a program for Floyd-Warshall Algorithm in C
Program:
#include <stdio.h>
#define INF 99999
void floydWarshall(int graph[][4], int V) {
int dist[V][V], i, j, k;
for (i = 0; i < V; i++) {
for (j = 0; j < V; j++) {
if (i == j) {
dist[i][j] = 0;
} else if (graph[i][j] != 0) {
dist[i][j] = graph[i][j];
} else {
dist[i][j] = INF;
for (k = 0; k < V; k++) {
for (i = 0; i < V; i++) {
for (j = 0; j < V; j++) {
if (dist[i][j] > dist[i][k] + dist[k][j]) {
dist[i][j] = dist[i][k] + dist[k][j];
}
printf("The shortest distance matrix is:\n");
for (i = 0; i < V; i++) {
for (j = 0; j < V; j++) {
if (dist[i][j] == INF) {
printf("INF ");
} else {
printf("%d ", dist[i][j]);
printf("\n");
int main() {
int graph[4][4] = {
{0, 3, INF, INF},
{3, 0, 1, INF},
{INF, 1, 0, 7},
{INF, INF, 7, 0}
};
int V = 4;
floydWarshall(graph, V);
return 0;
OUTPUT:
Input:
0---3---1
| |
INF 7
| |
3---INF---0
Output:
The shortest distance matrix is:
0 3 4 10
3018
4107
10 8 7 0
Experiment No: 10
Aim: Write a program to solve N-QUEENS problem.
Program:
#include <stdio.h>
#include <stdbool.h>
#define MAX 20
int board[MAX][MAX];
void printSolution(int n) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
printf("%d ", board[i][j]);
printf("\n");
bool isSafe(int n, int row, int col) {
int i, j;
for (i = 0; i < row; i++) {
if (board[i][col] == 1) {
return false;
for (i = row, j = col; i >= 0 && j >= 0; i--, j--) {
if (board[i][j] == 1) {
return false;
for (i = row, j = col; i >= 0 && j < n; i--, j++) {
if (board[i][j] == 1) {
return false;
return true;
bool solveNQueens(int n, int row) {
if (row == n) {
return true;
for (int col = 0; col < n; col++) {
if (isSafe(n, row, col)) {
board[row][col] = 1;
if (solveNQueens(n, row + 1)) {
return true;
board[row][col] = 0;
return false;
}
int main() {
int n;
printf("Enter the value of N: ");
scanf("%d", &n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
board[i][j] = 0;
if (solveNQueens(n, 0)) {
printf("Solution to %d-Queens problem is:\n", n);
printSolution(n);
} else {
printf("No solution exists for %d-Queens problem.\n", n);
return 0;
OUTPUT:
Input:
The user enters the value of N, which is the size of the board (NxN).
Output:
If a solution exists, the program prints the board with the queens' positions. If no solution exists,
it prints a message saying no solution exists.
