最小生成树的kruskal实现（加权union优化+压缩路径）

问题对标leetcode 1135题，问题描述：最低代价联通城市。

查并集的方法，其实就算加了两个优化也比较简单，也容易理解。

public class MapTest04 {
    //来装父亲节点的，全局变量
    public static int parent[] = new int[100];

    public static int minimumCost(int n, int connection[][]) {
        //边长不能小于节点数减一
        if (connection.length < n - 1) {
            return -1;
        }
        //为了不改变原始边的排序，复制一个数组
        int edges[][] = connection;
        //初始化父节点，设置为自己是为了find函数可以递归，从而达到压缩路径的目的
        for (int i = 0; i < n; i++) {
            parent[i] = i;
        }
        //kruskal算法，就是做个排序
        Arrays.sort(edges, new Comparator<int[]>() {
            public int compare(int[] o1, int[] o2) {
                return o1[2] - o2[2];
            }
        });
        int result = 0;
        //这是为了记录树的深度，目的是加权union
        int[] rank = new int[n];
        for (int i = 0; i < edges.length; i++) {
            int node1 = find(edges[i][0]);
            int node2 = find(edges[i][1]);
            int value = edges[i][2];
            if (node1 != node2) {
                //深度更大的包容深度更小的
                if (rank[node1] < rank[node2]) {
                    parent[node1] = node2;
                    result += value;
                } else if (rank[node1] > rank[node2]) {
                    parent[node2] = node1;
                    result += value;
                } else {
                    parent[node2] = node1;
                    rank[node1]++;
                    result += value;
                }
            }
        }
        return result;
    }

    public static int find(int x) {
        if (parent[x] != x) {
            parent[x] = find(parent[x]);
        }
        return parent[x];
    }

    public static void main(String[] args) {
        int arr[][] = {{0, 1, 1}, {0, 3, 100}, {3, 2, 1000}, {1, 2, 3}
                , {1, 3, 2}};
        int abc = minimumCost(4, arr);
        System.out.println(abc);
    }


}