这段代码是怎么参与到这个算法中的(GreedyAlgorithms/MST)

Question

我正在尝试学习这个算法，我可以理解它是如何工作的，并且我理解了大部分行，因为它取决于以前的教程，这里是 link 解释算法 https://www.cdn.geeksforgeeks.org/greedy-algorithms-set-2-kruskals-minimum-spanning-tree-mst/

这是算法

  class Graph
 {
    // A class to represent a graph edge
class Edge implements Comparable<Edge>
{
    int src, dest, weight;

    // Comparator function used for sorting edges 
    // based on their weight
    public int compareTo(Edge compareEdge)
    {
        return this.weight-compareEdge.weight;
    }
};

// A class to represent a subset for union-find
class subset
{
    int parent, rank;
};

int V, E;    // V-> no. of vertices & E->no.of edges
Edge edge[]; // collection of all edges

// Creates a graph with V vertices and E edges
Graph(int v, int e)
{
    V = v;
    E = e;
    edge = new Edge[E];
    for (int i=0; i<e; ++i)
        edge[i] = new Edge();
}

// A utility function to find set of an element i
// (uses path compression technique)
int find(subset subsets[], int i)
{
    // find root and make root as parent of i (path compression)
    if (subsets[i].parent != i)
        subsets[i].parent = find(subsets, subsets[i].parent);

    return subsets[i].parent;
}

// A function that does union of two sets of x and y
// (uses union by rank)
void Union(subset subsets[], int x, int y)
{
    int xroot = find(subsets, x);
    int yroot = find(subsets, y);

    // Attach smaller rank tree under root of high rank tree
    // (Union by Rank)
    if (subsets[xroot].rank < subsets[yroot].rank)
        subsets[xroot].parent = yroot;
    else if (subsets[xroot].rank > subsets[yroot].rank)
        subsets[yroot].parent = xroot;

    // If ranks are same, then make one as root and increment
    // its rank by one
    else
    {
        subsets[yroot].parent = xroot;
        subsets[xroot].rank++;
    }
}

// The main function to construct MST using Kruskal's algorithm
void KruskalMST()
{
    Edge result[] = new Edge[V];  // Tnis will store the resultant MST
    int e = 0;  // An index variable, used for result[]
    int i = 0;  // An index variable, used for sorted edges
    for (i=0; i<V; ++i)
        result[i] = new Edge();

    // Step 1:  Sort all the edges in non-decreasing order of their
    // weight.  If we are not allowed to change the given graph, we
    // can create a copy of array of edges
    Arrays.sort(edge);

    // Allocate memory for creating V ssubsets
    subset subsets[] = new subset[V];
    for(i=0; i<V; ++i)
        subsets[i]=new subset();

    // Create V subsets with single elements
    for (int v = 0; v < V; ++v)
    {
        subsets[v].parent = v;
        subsets[v].rank = 0;
    }

    i = 0;  // Index used to pick next edge

    // Number of edges to be taken is equal to V-1
    while (e < V - 1)
    {
        // Step 2: Pick the smallest edge. And increment 
        // the index for next iteration
        Edge next_edge = new Edge();
        next_edge = edge[i++];

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

        // If including this edge does't cause cycle,
        // include it in result and increment the index 
        // of result for next edge
        if (x != y)
        {
            result[e++] = next_edge;
            Union(subsets, x, y);
        }
        // Else discard the next_edge
    }

    // print the contents of result[] to display
    // the built MST
    System.out.println("Following are the edges in " + 
                                 "the constructed MST");
    for (i = 0; i < e; ++i)
        System.out.println(result[i].src+" -- " + 
               result[i].dest+" == " + result[i].weight);
}

// Driver Program
public static void main (String[] args)
{

    /* Let us create following weighted graph
             10
        0--------1
        |  \     |
       6|   5\   |15
        |      \ |
        2--------3
            4       */
    int V = 4;  // Number of vertices in graph
    int E = 5;  // Number of edges in graph
    Graph graph = new Graph(V, E);

    // add edge 0-1
    graph.edge[0].src = 0;
    graph.edge[0].dest = 1;
    graph.edge[0].weight = 10;

    // add edge 0-2
    graph.edge[1].src = 0;
    graph.edge[1].dest = 2;
    graph.edge[1].weight = 6;

    // add edge 0-3
    graph.edge[2].src = 0;
    graph.edge[2].dest = 3;
    graph.edge[2].weight = 5;

    // add edge 1-3
    graph.edge[3].src = 1;
    graph.edge[3].dest = 3;
    graph.edge[3].weight = 15;

    // add edge 2-3
    graph.edge[4].src = 2;
    graph.edge[4].dest = 3;
    graph.edge[4].weight = 4;

    graph.KruskalMST();
}

}

没看懂这段代码是怎么参与算法的

    public int compareTo(Edge compareEdge)
    {
        return this.weight-compareEdge.weight;
    }

我的意思是程序什么时候执行这部分？在行 ?

Answer 1

只要您使用 < 或 > 比较边，就会调用 compareTo 方法。它是一种实现 Comparable 接口的方法。 https://docs.oracle.com/javase/8/docs/api/java/lang/Comparable.html#compareTo-T-

Answer 2

在对 Edges 数组进行排序时，在这一行中隐式使用了它：

    Arrays.sort(edge);

Edge class 实现了 Comparable 接口。它有一个 compareTo 方法，允许将相关 class 的实例与相同 class 的另一个实例（这里是 Edge）进行比较以进行排序。查看 https://docs.oracle.com/javase/7/docs/api/java/lang/Comparable.html

这段代码是怎么参与到这个算法中的(GreedyAlgorithms/MST)

How does this code involved in this algorithm(Greedy Algorithms/MST)

java

algorithm

graph

greedy