// 1. Write a program to sort a list of N elements using Selection Sort Technique.

#include
int main()
{
int a[20], i, j, n, temp, pos;
printf("Enter the size of an array:");
scanf("%d", &n);
printf("Enter %d array elements:\n", n);
for (i = 0; i < n; i++)
scanf("%d", &a[i]);
for (i = 0; i < n; i++)
{
pos = i;
for (j = i + 1; j < n; j++)
{
if (a[j] < a[pos])
pos = j;
}
temp = a[pos];
a[pos] = a[i];
a[i] = temp;
}
printf("After Sorting:\n");
for (i = 0; i < n; i++)
printf("%d\t", a[i]);
return 0;
}

// 2. Write a program to implement Merge sort algorithm for sorting a list of integers in
//ascending order.
#include
int a[25], c[25], i, j, k;
void simple_merge(int a[], int low, int mid, int high)
{
int i = low, j = mid + 1, k = low;
while (i <= mid && j <= high)
{
if (a[i] < a[j])
c[k++] = a[i++];
else
c[k++] = a[j++];
}
while (i <= mid)
c[k++] = a[i++];
while (j <= high)
c[k++] = a[j++];
for (i = low; i <= high; i++)
a[i] = c[i];
}
void merge_sort(int a[], int low, int high)
{
int mid;
if (low < high)
{
mid = (low + high) / 2;
merge_sort(a, low, mid);
merge_sort(a, mid + 1, high);
simple_merge(a, low, mid, high);
}
}
int main()
{
int n;
printf("Enter the size of an array:");
scanf("%d", &n);
printf("Enter the array of elements:\n");
for (i = 0; i < n; i++)
scanf("%d", &a[i]);
merge_sort(a, 0, n - 1);
printf("After sorting:\n");
for (i = 0; i < n; i++)
printf("%d\t", a[i]);
return 0;
}

// 3. Write a test program to implement Divide and Conquer Strategy. Ex: Quick sort
//algorithm for sorting list of integers in ascending order.
#include
void quicksort(int a[25], int f, int l)
{
int i, j, pivot, temp;
if (f < l)
{
pivot = f;
i = f;
j = l;
while (i < j)
{
while (a[i] <= a[pivot] && i < l)
i++;
while (a[j] > a[pivot])
j--;
if (i < j)
{
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
temp = a[pivot];
a[pivot] = a[j];
a[j] = temp;
quicksort(a, f, j - 1);
quicksort(a, j + 1, l);
}
}
int main()
{
int i, n, l, a[25];
printf("Enter the size of an array:");
scanf("%d", &n);
printf("Enter %d array elements:\n", n);
for (i = 0; i < n; i++)
scanf("%d", &a[i]);
quicksort(a, 0, n - 1);
printf("After sorting:\n");
for (i = 0; i < n; i++)
printf("%d\t", a[i]);
return 0;
}

// 4. Sort a given set of n integer elements using Merge Sort method and compute its time
//complexity. Run the program for varied values of n> 5000, and record the time taken to
//sort.
#include
#include
#include
int a[50000], c[50000], n, i, j, k; // Note: n>5000 and n<50000
void simple_merge(int a[], int low, int mid, int high)
{
int i = low, j = mid + 1, k = low;
while (i <= mid && j <= high)
{
if (a[i] < a[j])
c[k++] = a[i++];
else
c[k++] = a[j++];
}
while (i <= mid)
c[k++] = a[i++];
while (j <= high)
c[k++] = a[j++];
for (i = low; i <= high; i++)
a[i] = c[i];
}
void merge_sort(int a[], int low, int high)
{
int mid;
if (low < high)
{
mid = (low + high) / 2;
merge_sort(a, low, mid);
merge_sort(a, mid + 1, high);
simple_merge(a, low, mid, high);
}
}
int main()
{
clock_t start, end;
double t;
printf("Enter the size:");
scanf("%d", &n);
for (i = 0; i < n; i++)
a[i] = rand(); // Random elements as per n values
start = clock();
merge_sort(a, 0, n - 1);
end = clock();
t = ((double)(end - start)) / CLOCKS_PER_SEC;
printf("After sorting:\n");
for (i = 0; i < n; i++)
printf("%d\t", a[i]);
printf("\nTime Taken to Sort------>%f", t);
return 0;
}

/ 5. Sort a given set of n integer elements using Quick Sort method and compute its time
//complexity. Run the program for varied values of n> 5000 and record the time taken to
//sort.
#include
#include
#include
int i, j, l, pivot, temp;
void quicksort(int a[], int f, int l)
{
if (f < l)
{
pivot = f;
i = f;
j = l;
while (i < j)
{
while (a[i] <= a[pivot] && i < l)
i++;
while (a[j] > a[pivot])
j--;
if (i < j)
{
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
temp = a[pivot];
a[pivot] = a[j];
a[j] = temp;
quicksort(a, f, j - 1);
quicksort(a, j + 1, l);
}
}
int main()
{
int n; // Note: n>5000
clock_t start, end;
double t;
printf("Enter the size of an array :");
scanf("%d", &n);
int a[n];
for (i = 0; i < n; i++)
a[i] = rand(); // Random elements as per n values
start = clock();
quicksort(a, 0, n - 1);
end = clock();
t = ((double)(end - start)) / CLOCKS_PER_SEC;
printf("After sorting\n");
for (i = 0; i < n; i++)
printf("%d\t", a[i]);
printf("\nTime Taken to Sort------>%f", t);
return 0;
}

// 6. Write C program that accepts the vertices and edges for a graph and stores it as an
//adjacency matrix.
#include
#define MAX_VERTICES 100
int main()
{
int adjMatrix[MAX_VERTICES][MAX_VERTICES] = {0};
int numVertices, numEdges;
int i, j, u, v;
printf("Enter the number of vertices in the graph: ");
scanf("%d", &numVertices);
printf("Enter the number of edges in the graph: ");
scanf("%d", &numEdges);
printf("Enter the edges (u, v):\n");
for (i = 0; i < numEdges; i++)
{
scanf("%d %d", &u, &v);
adjMatrix[u][v] = 1;
adjMatrix[v][u] = 1;
}
printf("\nAdjacency Matrix:\n");
for (i = 0; i < numVertices; i++)
{
for (j = 0; j < numVertices; j++)
{
printf("%d ", adjMatrix[i][j]);
}
printf("\n");
}
return 0;
}
/ 7. Write program to implement Dynamic Programming algorithm for the Optimal Binary
//Search Tree Problem.
#include
#include
int sum(int freq[], int i, int j);
int optimalSearchTree(int keys[], int freq[], int n)
{
int cost[n][n];
for (int i = 0; i < n; i++)
cost[i][i] = freq[i];
for (int L = 2; L <= n; L++)
{
for (int i = 0; i <= n - L + 1; i++)
{
int j = i + L - 1;
int off_set_sum = sum(freq, i, j);
cost[i][j] = INT_MAX;
for (int r = i; r <= j; r++)
{
int c = ((r > i) ? cost[i][r - 1] : 0) +
((r < j) ? cost[r + 1][j] : 0) +
off_set_sum;
if (c < cost[i][j])
cost[i][j] = c;
}
}
}
return cost[0][n - 1];
}
int sum(int freq[], int i, int j)
{
int s = 0;
for (int k = i; k <= j; k++)
s += freq[k];
return s;
}
int main()
{
int keys[] = {10, 12, 20};
int freq[] = {34, 8, 50};
int n = sizeof(keys) / sizeof(keys[0]);
printf("Cost of Optimal Binary Search Tree is %d ", optimalSearchTree(keys, freq, n));
return 0;
}

// 8. Write program to implement Dynamic Programming algorithm for the 0/1 Knapsack
//problem.
// Note: Program to Show maximum profit along with selected weights.
#include
int max(int a, int b) { return (a > b) ? a : b; }
void knapSack(int W, int wt[], int val[], int n)
{
int i, w;
int K[n + 1][W + 1];
for (i = 0; i <= n; i++)
{
for (w = 0; w <= W; w++)
{
if (i == 0 || w == 0)
K[i][w] = 0;
else if (wt[i - 1] <= w)
K[i][w] = max(val[i - 1] + K[i - 1][w - wt[i - 1]], K[i - 1][w]);
else
K[i][w] = K[i - 1][w];
}
}
int res = K[n][W];
printf("The Maximum Profit is %d\n", res);
printf("The Selected Weights are ");
w = W;
for (i = n; i > 0 && res > 0; i--)
{
if (res == K[i - 1][w])
continue;
else
{
printf("%d ", wt[i - 1]);
res = res - val[i - 1];
w = w - wt[i - 1];
}
}
}
int main()
{
int val[] = {60, 100, 120};
int wt[] = {10, 20, 30};
int W = 50;
int n = sizeof(val) / sizeof(val[0]);
knapSack(W, wt, val, n);
return 0;
}

/ 8. Write program to implement Dynamic Programming algorithm for the 0/1 Knapsack
//problem.
// Note: Program to Show maximum profit.
#include
int max(int a, int b) { return (a > b) ? a : b; }
int knapSack(int W, int wt[], int val[], int n)
{
if (n == 0 || W == 0)
return 0;
if (wt[n - 1] > W)
return knapSack(W, wt, val, n - 1);
else
return max(val[n - 1] + knapSack(W - wt[n - 1], wt, val, n - 1), knapSack(W, wt,
val, n - 1));
}
int main()
{
int val[] = {60, 100, 120};
int wt[] = {10, 20, 30};
int W = 50;
int n = sizeof(val) / sizeof(val[0]);
printf("The Maximum Profit is %d\n", knapSack(W, wt, val, n));
return 0;
}

// 9. Write a program to find minimum and maximum values in an array using divide and
//conquer.
#include
int max, min, a[100];
void maxmin(int i, int j)
{
int max1, min1, mid;
if (i == j)
max = min = a[i];
else if (i == j - 1)
{
if (a[i] < a[j])
{
max = a[j];
min = a[i];
}
else
{
max = a[i];
min = a[j];
}
}
else
{
mid = (i + j) / 2;
maxmin(i, mid);
max1 = max;
min1 = min;
maxmin(mid + 1, j);
if (max < max1)
max = max1;
if (min > min1)
min = min1;
}
}
int main()
{
int n, i;
printf("Enter the size of an array: ");
scanf("%d", &n);
printf("Enter %d array elements: \n", n);
for (i = 1; i <= n; i++)
scanf("%d", &a[i]);

max = min = a[0]; //Optional

maxmin(1, n);
printf("\nMaximum element of the array is %d", max);
printf("\nMinimum element of the array is %d", min);
return 0;
}

// 10. Write a program that implements Prim’s algorithm to generate minimum cost spanning
//Tree.
#include
#define vertex 4
int minKey(int key[], int mstSet[])
{
int min = 999, min_index, v;
for (v = 0; v < vertex; v++)
if (mstSet[v] == 0 && key[v] < min)
min = key[v], min_index = v;
return min_index;
}
void printMST(int parent[], int graph[vertex][vertex])
{
int i, totalWeight = 0;
printf("Edge \tWeight\n");
for (i = 1; i < vertex; i++)
{
printf("%d - %d \t%d \n", parent[i], i, graph[i][parent[i]]);
totalWeight += graph[i][parent[i]];
}
printf("\nTotal Cost of Spanning Tree: %d\n", totalWeight);
}
void primsMST(int graph[vertex][vertex])
{
int i, u, v, count;
int parent[vertex], key[vertex], mstSet[vertex];
for (i = 0; i < vertex; i++)
key[i] = 999, mstSet[i] = 0;
key[0] = 0;
parent[0] = -1;
for (count = 0; count < vertex - 1; count++)
{
int u = minKey(key, mstSet);
mstSet[u] = 1;
for (v = 0; v < vertex; v++)
if (graph[u][v] && mstSet[v] == 0 && graph[u][v] < key[v])
parent[v] = u, key[v] = graph[u][v];
}
printMST(parent, graph);
}
int main()
{
int graph[vertex][vertex] = {{0, 4, 2, 2},
{4, 0, 6, 1},
{2, 6, 0, 5},
{2, 1, 5, 0}};
primsMST(graph);
return 0;
}