Question

我试图学习这个算法，我可以按照它是如何工作的，我理解大多数线，因为它取决于之前的教程，这里是一个解释算法的链接 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

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

    Arrays.sort(edge);

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

Answer 2

只要您使用$ jq -n --argjson NODESTOTAL 1 --argjson NODESUSED 2 --argjson NODESFREE 3 --argjson NODESPERCENT 4 -f inode-template.jq { "name": "inodeparse", "metrics": [ { "event_type": "test", "provider": "test", "fileSystem": "FILESYS", "InodesTotal": 1, "InodesUsed": 2, "InodesFree": 3, "InodeUsedPercent": 4 } ] }或<来比较边，就会调用compareTo方法。这是一种实现Comparable接口的方法。 https://docs.oracle.com/javase/8/docs/api/java/lang/Comparable.html#compareTo-T-

这个代码如何参与此算法（Greedy Algorithms / MST）

2 个答案: