Time efficiency in Kruskal's algorithm using adjacency matrix as data structure

问题

This is the pseudo code I used for Kruskal's algorithm. The data structure I have used here is an adjacency matrix. I got the order of growth as n^2. I want to know whether it is correct or not.

Kruskal’s Pseudo code

1. Kruskal (n, m, E)
2. // Purpose to compute the minimum spanning tree using Kruskal's algorithm
3. // Inputs
4.  n - Number of vertices in the graph
5.  m - Number of edges in the graph
6.  E - Edge list consisting of set of edges along with equivalent weight
    w - cost adjacency matrix with values >0
7.  con – constrain adjacency matrix 
8. // Output: - the minimum spanning tree along
9.  count - shortest distance from the source to all other nodes
d - shortest distance from source to all other nodes
10. p - shortest path from source to destination
11. s - gives the nodes that are so far visited and nodes that are not visited  
12.  s [source] <- 1
13.  For i = 0 to n-1 Do
14. If con[u, i] == T Then
15.     add u to S
16.     select edge that need to be connected
17.     add cost associated with edge to get total cost of minimal spanning tree
18. Else
19.     find u and d[u] such that d[u] is minimum and u Є V - S
20.     add u to S
21. End If
22. If u = destination Then
23.     End
24. End If
25. For every v Є V - S Do
26.     If con[u, v] ==  T Then
27.         d[v] <-  d[u] + w[u, v]
28.         p[v] <-  u
29.     ElseIf d[u] + w[u, v]<d[v] Then
30.         d[v] <-  d[u] + w[u, v]
31.         p[v] <-  u
32.     End If
33. End For
34. End For

回答1:

Depending on your actual implementation and data structures involved, time complexity of this algorithm can be bad. That is why adjacency lists are a more appropriate structure for Kruskal's algorithm: you need to be able to identify two things as fast as possible:

1. Find the next min. weight edge,

2. Check if an edge connects two different trees (or if two vertices belong to the same component).

To achieve O(N log N) complexity, this means you need to:

1. sort the edges by weight first. That will make the step where you are looking for the next minimum weight edge an O(1) operation, and

2. use a structure like union-find to identify quickly which vertices are in which components.

For reference, you can check this CodeProject article (a C# implementation).

来源：https://stackoverflow.com/questions/9092339/time-efficiency-in-kruskals-algorithm-using-adjacency-matrix-as-data-structure