0% found this document useful (0 votes)
38 views21 pages

Daa Front Page

Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
38 views21 pages

Daa Front Page

Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 21

Experiment No : ……………………………… Date: ……………………………

Date: …………………………………… Roll No: ……………………….

DESIGN AND ANALYSIS OF ALGORITHM

Name: Siddharth

Course: BTECH(CSE)

Class: 3rd Year ‘C’

College ID: 2100747

Roll no: 2101320100161

Session: 2023 - 24

Subject Code: KCS553

Submitted To: Ms. Saurabhi Chaudhary

College code: 132

Faculty Name: ………………………………… Sign. With date: …...........................


Experiment No : ……………………………… Date: ……………………………

Date: …………………………………… Roll No: ……………………….

S. No OBJECT DATE SIGNATURE REMARKS

1.
Program for recursive binary
and linear search

2.
Program for heap sort

3.
Program for merge sort

4.

Program for selection sort

5.

Program for Insertion sort

6.

Program for quick sort

7. Knapsack problem using greedy


solution

8. Perform travelling salesman


problem

Faculty Name: ………………………………… Sign. With date: …...........................


Experiment No : ……………………………… Date: ……………………………

Date: …………………………………… Roll No: ……………………….

S. No OBJECT DATE SIGNATURE REMARKS

9. Find the minimum Spanning


tree using kruskal’s algorithm

10.

11.

Faculty Name: ………………………………… Sign. With date: …...........................


Experiment No : ……………………………… Date: ……………………………

Date: …………………………………… Roll No: ……………………….

1.PROGRAM FOR RECURSIVE BINARY SEARCH & LINEAR SEARCH.


#include <stdio.h> // Binary Search
int binary_search_recursive(int arr[], int target, int low, int high) { if
(low > high) { return -1;
}

int mid = (low + high) / 2;


if (arr[mid] == target)
{ return mid;
} else if (arr[mid] < target) {

return binary_search_recursive(arr, target, mid + 1, high);

} else {

return binary_search_recursive(arr, target, low, mid - 1);

// Linear Search

int linear_search(int arr[], int size, int target)


{ for (int i = 0; i < size; ++i) { if (arr[i] ==
target) { return i;
}

return -1;

int main() {

int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};


int target = 7; int low = 0;
int high = sizeof(arr) / sizeof(arr[0]) - 1;

// Binary Search

int result = binary_search_recursive(arr, target, low, high); if


(result != -1) {
printf("Element %d is present at index %d\n", target, result);

} else {
Faculty Name: ………………………………… Sign. With date: …...........................
Experiment No : ……………………………… Date: ……………………………

Date: …………………………………… Roll No: ……………………….

printf("Element %d is not present in the array\n", target);

// Linear Search

int linearSearchResult = linear_search(arr, size, target); if


(linearSearchResult != -1) {
printf("Linear Search: Element %d is present at index %d\n", target, linearSearchResult);

} else {

printf("Linear Search: Element %d is not present in the array\n", target);

return 0;

OUTPUT

Faculty Name: ………………………………… Sign. With date: …...........................


Experiment No : ……………………………… Date: ……………………………

Date: …………………………………… Roll No: ……………………….

2. PROGRAM FOR HEAP SORT.


#include <stdio.h> 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) { int
temp = arr[i]; arr[i] =
arr[largest]; arr[largest] =
temp; 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--) {


int temp = arr[0]; arr[0] =
arr[i]; arr[i] = temp;
heapify(arr, i, 0);
}

void printArray(int arr[], int n)


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

printf("\n");

}
Faculty Name: ………………………………… Sign. With date: …...........................
Experiment No : ……………………………… Date: ……………………………

Date: …………………………………… Roll No: ……………………….

int main() { int arr[] = {12, 11, 13, 5,


6, 7}; int n = sizeof(arr) /
sizeof(arr[0]); printf("Original array:
"); printArray(arr, n);
heapSort(arr, n); printf("Sorted
array: "); printArray(arr, n); return
0;
}

OUTPUT

Faculty Name: ………………………………… Sign. With date: …...........................


Experiment No : ……………………………… Date: ……………………………

Date: …………………………………… Roll No: ……………………….

3. PROGRAM FOR MERGE SORT.


#include <stdio.h> void merge(int arr[],
int l, int m, int r) {
int i, j, k; int n1 = m - l
+ 1; int n2 = r - m; int
L[n1], R[n2]; for (i = 0; i
< n1; i++) L[i] = arr[l +
i]; for (j = 0; j < n2; j++)
R[j] = arr[m + 1 + j]; i=
0; j = 0; k = l;
while (i < n1 && j < n2) {
if (L[i] <= R[j]) { arr[k]
= L[i]; i++; } else {
arr[k] = R[j]; j++;
}
k++;
}

while (i < n1) {


arr[k] = L[i];
i++; k++;
}

while (j < n2)


{ arr[k] = R[j]; j+
+; k++;
}

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

if (l < r) { int m = l + (r -
l) / 2; mergeSort(arr, l, m);
mergeSort(arr, m + 1, r);
merge(arr, l, m, r);
}

Faculty Name: ………………………………… Sign. With date: …...........................


Experiment No : ……………………………… Date: ……………………………

Date: …………………………………… Roll No: ……………………….

void printArray(int A[], int size) { for


(int i = 0; i < size; i++) printf("%d ",
A[i]); printf("\n");
}

int main() { int arr[] = {12, 11, 13, 5, 6, 7};


int arr_size = sizeof(arr) / sizeof(arr[0]);
printf("Original array: "); printArray(arr,
arr_size); mergeSort(arr, 0, arr_size - 1);
printf("Sorted array: "); printArray(arr,
arr_size); return 0;
}

OUTPUT

Faculty Name: ………………………………… Sign. With date: …...........................


Experiment No : ……………………………… Date: ……………………………

Date: …………………………………… Roll No: ……………………….

4. PROGRAM FOR SELECTION SORT.


#include <stdio.h> void
swap(int *xp, int *yp) { int
temp = *xp; *xp = *yp;
*yp = temp;

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


i, j, min_idx;

for (i = 0; i < n-1; i++)


{ min_idx = i;

for (j = i+1; j < n; j++) if


(arr[j] < arr[min_idx])
min_idx = j;
swap(&arr[min_idx], &arr[i]);
}

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

int i;

for (i=0; i < size; i++)


printf("%d ", arr[i]);
printf("\n");
}

int main() {

int arr[] = {64, 25, 12, 22, 11}; int


n = sizeof(arr)/sizeof(arr[0]);

Faculty Name: ………………………………… Sign. With date: …...........................


Experiment No : ……………………………… Date: ……………………………

Date: …………………………………… Roll No: ……………………….


selectionSort(arr, n); printf("Sorted
array: "); printArray(arr, n);
return 0;
}

OUTPUT

Faculty Name: ………………………………… Sign. With date: …...........................


Experiment No : ……………………………… Date: ……………………………

Date: …………………………………… Roll No: ……………………….

5. PROGRAM FOR INSERTION SORT.


#include <stdio.h> void
insertionSort(int arr[], int n) { int i,
key, j; for (i = 1; i < n; i++) { key
= arr[i]; j = i - 1;
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j]; j = j - 1;
}

arr[j + 1] = key;

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

int i; for (i = 0; i < size;


i++) printf("%d ",
arr[i]); printf("\n");
}

int main() { int arr[] = {12, 11, 13, 5,


6}; int n = sizeof(arr) / sizeof(arr[0]);
insertionSort(arr, n); printf("Sorted
array: "); printArray(arr, n); return
0;
}

OUTPUT

Faculty Name: ………………………………… Sign. With date: …...........................


Experiment No : ……………………………… Date: ……………………………

Date: …………………………………… Roll No: ……………………….

6. PROGRAM FOR QUICK SORT.


#include <stdio.h>

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


int t = *a; *a = *b;
*b = t;

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


{ int pivot = arr[high]; int i = (low - 1);
for (int j = low; j <= high - 1; j++) { if
(arr[j] < pivot) { i++;
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");
}

Faculty Name: ………………………………… Sign. With date: …...........................


Experiment No : ……………………………… Date: ……………………………

Date: …………………………………… Roll No: ……………………….

int main() { int arr[] = {10, 7, 8, 9, 1,


5}; int n = sizeof(arr) / sizeof(arr[0]);

quickSort(arr, 0, n - 1);

printf("Sorted array: "); printArray(arr,


n);

return 0;

OUTPUT

Faculty Name: ………………………………… Sign. With date: …...........................


Experiment No : ……………………………… Date: ……………………………

Date: …………………………………… Roll No: ……………………….

7. KNAPSACK PROBLEM USING GREEDY SOLUTION.


#include <stdio.h>
#include <stdlib.h>
struct Item { int
value; int weight;
};

int compare(const void *a, const void *b) {

double ratioA = ((struct Item*)a)->value / (double)((struct Item*)a)->weight; double


ratioB = ((struct Item*)b)->value / (double)((struct Item*)b)->weight; return (ratioB >
ratioA) ? 1 : -1;
}

void knapsackGreedy(struct Item items[], int n, int capacity)


{ qsort(items, n, sizeof(struct Item), compare); int
currentWeight = 0; double finalValue = 0.0;

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

if (currentWeight + items[i].weight <= capacity) {


currentWeight += items[i].weight; finalValue +=
items[i].value;
} else {

int remainingWeight = capacity - currentWeight;

finalValue += items[i].value * ((double)remainingWeight / items[i].weight);


break;
}

printf("Maximum value in Knapsack = %.2f\n", finalValue);

int main() {

Faculty Name: ………………………………… Sign. With date: …...........................


Experiment No : ……………………………… Date: ……………………………

Date: …………………………………… Roll No: ……………………….

struct Item items[] = {{60, 10}, {100, 20}, {120, 30}}; int
n = sizeof(items) / sizeof(items[0]); int capacity = 50;
knapsackGreedy(items, n, capacity); return 0;
}

OUTPUT

Faculty Name: ………………………………… Sign. With date: …...........................


Experiment No : ……………………………… Date: ……………………………

Date: …………………………………… Roll No: ……………………….

8. PERFORM TRAVELLING SALESMAN PROBLEM.


#include <stdio.h>
#include <limits.h> int
graph[V][V] = { {0,
10, 15, 20},
{10, 0, 35, 25},

{15, 35, 0, 30},

{20, 25, 30, 0}

};

int visited[V]; int minDistance(int dist[], int n)


{ int min = INT_MAX, min_index; for (int
v = 0; v < n; v++) { if (visited[v] == 0 &&
dist[v] <= min) { min = dist[v];
min_index = v;
} }

return min_index;} void


printPath(int parent[], int j) { if
(parent[j] == -1) return;
printPath(parent, parent[j]);
printf("%d ", j);
}

void printSolution(int dist[], int parent[], int n) { int


src = 0;
printf("Vertex\t Distance\tPath"); for
(int i = 1; i < n; i++) {
printf("\n%d -> %d \t%d\t\t%d ", src, i, dist[i], src);

printPath(parent, i);

printf("\n");

Faculty Name: ………………………………… Sign. With date: …...........................


Experiment No : ……………………………… Date: ……………………………

Date: …………………………………… Roll No: ……………………….

void tsp() { int dist[V];


int parent[V]; for (int i =

0; i < V; i++) { dist[i] =


INT_MAX; visited[i] = 0;
}

dist[0] = 0; parent[0]
= -1;
for (int count = 0; count < V - 1; count++) {
int u = minDistance(dist, V); visited[u] = 1;
for (int v = 0; v < V; 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]; parent[v] = u;
}} }

printSolution(dist, parent, V);

int main()
{ tsp();
return 0;
}

OUTPUT

Faculty Name: ………………………………… Sign. With date: …...........................


Experiment No : ……………………………… Date: ……………………………

Date: …………………………………… Roll No: ……………………….

9. FIND MINIMUM SPANNING TREE USING KRUSKAL ALGORITHM.


#include <stdio.h>

#include <stdlib.h>

struct Edge { int src,


dest, weight;
};

struct Subset { int


parent, rank;
};

int find(struct Subset subsets[], int i) { if


(subsets[i].parent != i)
subsets[i].parent = find(subsets, subsets[i].parent); return
subsets[i].parent;
}

void Union(struct Subset subsets[], int x, int y)


{ int xroot = find(subsets, x); int yroot =
find(subsets, y);

if (subsets[xroot].rank < subsets[yroot].rank) subsets[xroot].parent =


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

Faculty Name: ………………………………… Sign. With date: …...........................


Experiment No : ……………………………… Date: ……………………………

Date: …………………………………… Roll No: ……………………….

int compare(const void* a, const void* b) {

return ((struct Edge*)a)->weight - ((struct Edge*)b)->weight;

void kruskal(struct Edge edges[], int V, int E)


{ struct Edge result[V]; int e = 0, i = 0;

qsort(edges, E, sizeof(edges[0]), compare);

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

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


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

while (e < V - 1 && i < E) { struct Edge


next_edge = edges[i++];

int x = find(subsets, next_edge.src);


int y = find(subsets, next_edge.dest);

if (x != y) {

result[e++] = next_edge;

Union(subsets, x, y);

printf("Edges in the Minimum Spanning Tree:\n");

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

printf("%d - %d\tWeight: %d\n", result[i].src, result[i].dest, result[i].weight);

Faculty Name: ………………………………… Sign. With date: …...........................


Experiment No : ……………………………… Date: ……………………………

Date: …………………………………… Roll No: ……………………….


}

free(subsets);

int main()
{ int V = 4;
int E = 5;

struct Edge edges[] = {

{0, 1, 10},

{0, 2, 6},
{0, 3, 5},
{1, 3, 15},

{2, 3, 4}

};

kruskal(edges, V, E);

return 0;

OUTPUT

Faculty Name: ………………………………… Sign. With date: …...........................

You might also like

pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy