Implementation of Prim's algorithm in C language

The following is the C language implementation of Prim's Algorithm:

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <stdbool.h>
5. #define INF 99999 // Infinity, indicating unreachable
7. int n; // number of vertices
8. int m; // number of sides
9. int graph[10][10]; // graph represented by adjacency matrix
11. int prim() {
12.     int parent[10]; //Storage the parent node of each vertex in the constructed MST
13.     int key[10]; //Storage the distance (weight) from each vertex to MST
14.     bool visited[10] = {false}; // Mark each vertex whether it has been visited
15.     for (int i = 0; i < n; i++) {
16.         key[i] = INF; // Initialize the distance from all vertices to MST to infinity
17.     }
18.     key[0] = 0; // Let the first vertex be the first vertex of MST
19.     parent[0] = -1; // The first vertex is the first vertex of MST
20.     for (int i = 0; i < n - 1; i++) {
21.         // Select a vertex v with the smallest distance from the unvisited vertices
22.         int min_key = INF;
23.         int min_index = -1;
24.         for (int j = 0; j < n; j++) {
25.             if (!visited[j] && key[j] < min_key) {
26.                 min_key = key[j];
27.                 min_index = j;
28.             }
29.         }
30.         visited[min_index] = true; // Mark the selected vertex v as visited
31.         // Update the distance from the vertex adjacent to v to MST
32.         for (int j = 0; j < n; j++) {
33.             if (graph[min_index][j] != 0 && !visited[j] && graph[min_index][j] < key[j]) {
34.                 parent[j] = min_index; // Set the parent node of j to min_index, that is, v
35.                 key[j] = graph[min_index][j]; // Update key[j], that is, update the distance from j to MST
36.             }
37.         }
38.     }
39.     // Output the weight of each vertex in the constructed MST and the parent node in the MST
40.     printf("Edge \tWeight\n");
41.     for (int i = 1; i < n; i++) {
42.         printf("%d - %d \t%d\n", parent[i], i, graph[i][parent[i]]);
43.     }
44.     return 0;
45. }
47. int main() {
48.     printf("Enter the number of vertices and edges: ");
49.     scanf("%d %d", &n, &m);
50.     printf("Enter the adjacency matrix of the graph:\n");
51.     for (int i = 0; i < m; i++) {
52.         for (int j = 0; j < n; j++) {
53.             scanf("%d", &graph[i][j]);
54.         }
55.     }
56.     prim(); // Call the Prim function to solve MST and output the result
57.     return 0;
58. }

This code implements Prim's Algorithm to find the Minimum Spanning Tree (MST) of a given graph. Here's an explanation of the code's flow:

1. Enter the number of vertices n and the number of edges m.
2. Enter the graph represented by the adjacency matrix. The adjacency matrix is ​​an n×n two-dimensional array, where graph[i][j] represents the weight of the edge between vertex i and vertex j, and 0 represents no edge between the two vertices. .
3. Define an array parent to store the parent node of each vertex in the constructed MST. Initially, the parent node of all vertices except the first vertex (the starting point) is set to -1.
4. Define an array key to store the distance (weight) of each vertex to MST. During initialization, set the distance from all vertices to MST to infinity, except the distance from the starting point to MST, which is set to 0.
5. Define an array visited to mark whether each vertex has been visited. Initially, all vertices have not been visited.
6. In the while loop, select a vertex v with the smallest distance from the unvisited vertices. Selecting a vertex with the smallest distance from these unvisited vertices can be achieved by traversing all unvisited vertices and updating their distances.
7. Mark the selected vertex v as visited, and update the distance from the vertices adjacent to v to the MST. If the distance between an adjacent vertex is less than the current distance from the vertex to the MST, update the distance from the vertex to the MST and set the parent node of the vertex to v.
8. Repeat the above steps until all vertices have been visited or MST contains n-1 edges.
9. Output the weight of each vertex in the constructed MST and the parent node in the MST. This can be achieved by traversing all vertices and outputting their parent nodes and weights.

This code uses an adjacency matrix to represent the graph, which is a more intuitive way. However, in practical applications, in order to reduce memory usage and improve operating efficiency, other data structures such as adjacency lists are usually used to represent graphs.