Merge branch 'main' of https://github.com/githubhosting/DAA-Lab

namratha-vj · namratha-vj · commit 41d44a8d5463 · 2023-08-14T10:01:07.000+05:30
diff --git a/10.krushkal.c b/10.krushkal.c
@@ -27,7 +27,7 @@ void main()
     }
 
     printf("\nThe edges of Minimum Cost Spanning Tree are\n");
-    while (ne < n)
+    while (ne < n) // n-1 edges
     {
         for (i = 1, min = 999; i <= n; i++)
         {
diff --git a/11.dijkstras.c b/11.dijkstras.c
@@ -1,7 +1,10 @@
 #include <stdio.h>
+#include <stdlib.h>
 #define INFINITY 9999
 #define MAX 10
+
 void dijkstra(int G[MAX][MAX], int n, int startnode);
+
 int main()
 {
 	int G[MAX][MAX], i, j, n, u;
@@ -16,10 +19,11 @@ int main()
 	dijkstra(G, n, u);
 	return 0;
 }
+
 void dijkstra(int G[MAX][MAX], int n, int startnode)
 {
-	int cost[MAX][MAX], distance[MAX], pred[MAX];
-	int visited[MAX], count, mindistance, nextnode, i, j;
+	int cost[MAX][MAX], distance[MAX], from[MAX];
+	int visited[MAX], count, min_distance, nextnode, i, j;
 	// pred[] stores the predecessor of each node
 	// count gives the number of nodes seen so far
 	// create the cost matrix
@@ -29,34 +33,34 @@ void dijkstra(int G[MAX][MAX], int n, int startnode)
 				cost[i][j] = INFINITY;
 			else
 				cost[i][j] = G[i][j];
-	// initialize pred[],distance[] and visited[]
+	// initialise visited[], distance[] and from[]
+	distance[startnode] = 0;
+	visited[startnode] = 1;
 	for (i = 0; i < n; i++)
 	{
 		distance[i] = cost[startnode][i];
-		pred[i] = startnode;
+		from[i] = startnode;
 		visited[i] = 0;
 	}
-	distance[startnode] = 0;
-	visited[startnode] = 1;
 	count = 1;
 	while (count < n - 1)
 	{
-		mindistance = INFINITY;
+		min_distance = INFINITY;
 		// nextnode gives the node at minimum distance
 		for (i = 0; i < n; i++)
-			if (distance[i] < mindistance && !visited[i])
+			if (distance[i] < min_distance && !visited[i])
 			{
-				mindistance = distance[i];
 				nextnode = i;
+				min_distance = distance[i];
 			}
 		// check if a better path exists through nextnode
 		visited[nextnode] = 1;
 		for (i = 0; i < n; i++)
 			if (!visited[i])
-				if (mindistance + cost[nextnode][i] < distance[i])
+				if (min_distance + cost[nextnode][i] < distance[i])
 				{
-					distance[i] = mindistance + cost[nextnode][i];
-					pred[i] = nextnode;
+					distance[i] = min_distance + cost[nextnode][i];
+					from[i] = nextnode;
 				}
 		count++;
 	}
@@ -69,7 +73,7 @@ void dijkstra(int G[MAX][MAX], int n, int startnode)
 			j = i;
 			do
 			{
-				j = pred[j];
+				j = from[j];
 				printf("<-%d", j);
 			} while (j != startnode);
 		}
diff --git a/3.Bubble_Insertion.c b/3.Bubble_Insertion.c
@@ -23,7 +23,7 @@ void insertionSort(int *array, int size)
     for (int i = 1; i < size; i++)
     {
         key = array[i]; // take value
-        j = i;
+        j = i;          // take index
         while (j > 0 && array[j - 1] > key)
         {
             array[j] = array[j - 1];
diff --git a/6.BFS.c b/6.BFS.c
@@ -22,7 +22,7 @@ void bfs(int v)
 main()
 {
     int v, i, j;
-    printf("\n Enter the number of vertices:");
+    printf("\n Enter the number of vertices: ");
     scanf("%d", &n);
     for (i = 0; i < n; i++) // mark all the vertices as not visited
     {
diff --git a/9.prims.c b/9.prims.c
@@ -1,23 +1,21 @@
 #include <stdio.h>
 #include <stdlib.h>
-
 #define infinity 9999
 #define MAX 20
 
-int G[MAX][MAX], spanning[MAX][MAX], n;
-
-int prims();
+int prims(int G[MAX][MAX], int spanning[MAX][MAX], int n);
 
 int main()
 {
+    int G[MAX][MAX], spanning[MAX][MAX], n;
     int i, j, total_cost;
     printf("Enter no. of vertices: ");
     scanf("%d", &n);
     printf("\nEnter the adjacency matrix: \n");
     for (i = 0; i < n; i++)
         for (j = 0; j < n; j++)
             scanf("%d", &G[i][j]);
-    total_cost = prims();
+    total_cost = prims(G, spanning, n);
     printf("\nspanning tree matrix:\n");
     for (i = 0; i < n; i++)
     {
@@ -29,7 +27,7 @@ int main()
     return 0;
 }
 
-int prims()
+int prims(int G[MAX][MAX], int spanning[MAX][MAX], int n)
 {
     int cost[MAX][MAX];
     int u, v, min_distance, distance[MAX], from[MAX];
@@ -69,7 +67,7 @@ int prims()
                 min_distance = distance[i];
             }
         u = from[v];
-        
+
         // insert the edge in spanning tree
         spanning[u][v] = distance[v];
         spanning[v][u] = distance[v];
diff --git a/lab-manual/11.dijkstras.c b/lab-manual/11.dijkstras.c
@@ -19,7 +19,7 @@ int main()
 void dijkstra(int G[MAX][MAX], int n, int startnode)
 {
     int cost[MAX][MAX], distance[MAX], pred[MAX];
-    int visited[MAX], count, mindistance, nextnode, i, j;
+    int visited[MAX], count, min_distance, nextnode, i, j;
     // pred[] stores the predecessor of each node
     // count gives the number of nodes seen so far
     // create the cost matrix
@@ -41,21 +41,21 @@ void dijkstra(int G[MAX][MAX], int n, int startnode)
     count = 1;
     while (count < n - 1)
     {
-        mindistance = INFINITY;
+        min_distance = INFINITY;
         // nextnode gives the node at minimum distance
         for (i = 0; i < n; i++)
-            if (distance[i] < mindistance && !visited[i])
+            if (distance[i] < min_distance && !visited[i])
             {
-                mindistance = distance[i];
+                min_distance = distance[i];
                 nextnode = i;
             }
         // check if a better path exists through nextnode
         visited[nextnode] = 1;
         for (i = 0; i < n; i++)
             if (!visited[i])
-                if (mindistance + cost[nextnode][i] < distance[i])
+                if (min_distance + cost[nextnode][i] < distance[i])
                 {
-                    distance[i] = mindistance + cost[nextnode][i];
+                    distance[i] = min_distance + cost[nextnode][i];
                     pred[i] = nextnode;
                 }
         count++;
diff --git a/lab-manual/2.Linear_Binary.cpp b/lab-manual/2.Linear_Binary.cpp
@@ -14,11 +14,13 @@ int Linear_search()
     cout << "\n Enter a Number to Search: ";
     cin >> num;
     start = clock();
+    int flag = 0;
     for (i = 0; i < n; i++)
     {
         if (arr[i] == num)
         {
             index = i;
+            flag = 1;
             break;
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ void main()`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`printf("\nThe edges of Minimum Cost Spanning Tree are\n");`
`30`		`- while (ne < n)`
	`30`	`+ while (ne < n) // n-1 edges`
`31`	`31`	`{`
`32`	`32`	`for (i = 1, min = 999; i <= n; i++)`
`33`	`33`	`{`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ void insertionSort(int *array, int size)`
`23`	`23`	`for (int i = 1; i < size; i++)`
`24`	`24`	`{`
`25`	`25`	`key = array[i]; // take value`
`26`		`- j = i;`
	`26`	`+ j = i; // take index`
`27`	`27`	`while (j > 0 && array[j - 1] > key)`
`28`	`28`	`{`
`29`	`29`	`array[j] = array[j - 1];`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ void bfs(int v)`
`22`	`22`	`main()`
`23`	`23`	`{`
`24`	`24`	`int v, i, j;`
`25`		`- printf("\n Enter the number of vertices:");`
	`25`	`+ printf("\n Enter the number of vertices: ");`
`26`	`26`	`scanf("%d", &n);`
`27`	`27`	`for (i = 0; i < n; i++) // mark all the vertices as not visited`
`28`	`28`	`{`
Original file line number	Diff line number	Diff line change
`@@ -14,11 +14,13 @@ int Linear_search()`
`14`	`14`	`cout << "\n Enter a Number to Search: ";`
`15`	`15`	`cin >> num;`
`16`	`16`	`start = clock();`
	`17`	`+ int flag = 0;`
`17`	`18`	`for (i = 0; i < n; i++)`
`18`	`19`	`{`
`19`	`20`	`if (arr[i] == num)`
`20`	`21`	`{`
`21`	`22`	`index = i;`
	`23`	`+ flag = 1;`
`22`	`24`	`break;`
`23`	`25`	`}`
`24`	`26`	`}`