克鲁斯卡尔算法

克鲁斯卡尔算法（Kruskal）：
图论中的一种算法，用来在加权连通图中构造最小代价生成树，何为最小代价生成树呢，也就是通过此算法生成的树，不但包括了原连通图中的所有节点，而且保证了所有边的权值之和最小。

算法核心思想：在给定的带权连通图中，选择一个当前还未被选择过的，加入后不会再最小代价生成树构成回路的，而且权值最小的边，将其添加到正在构造中的最小代价生成树中

基本原理：
现有一个加权联通图，顶点集合为V，边的集合为E，构造最小代价生成树时，Vnew代表生成树的顶点集合，Enew代表生成树的边的集合，最小代价生成树的过程如下：
1.初始化，Vnew = V，Enew = {}，即生成树包含原图中的所有节点，但是没有边
2.从E中选择权值最小的边<u,v>，如果这条边加入后不会形成回路，就把这条边添加到Enew中，并在E中删去这条边，否则选择权值第二小的边
重复步骤2，直到Enew中包含n-1条边，n为原图中的顶点个数

其实Kruskal算法最主要的部分就是如何去判断加入这条边后会不会形成回路，这个问题可以通过判断边的两个顶点是否在同一个联通分量中，若两个顶点不属于同一个联通分量，则将这条边添加后就不会形成回路，判断算法采用并查集的思路，详见并查集概述
实现代码如下：

//初始化
int[] father;
int[] rank;
void init(int n){
	father = new int[n];
	rank = new int[n];
	for(int i=0;i<n;i++){
		father[i] = i;
		rank[i] = 1;
	}
}
//查找
int find(int x){
	if(x==father[x]{
		return x;
	}else{
		//将路径上的每一个节点的父节点直接设置为根节点
		father[x] =find(father[x]);
		return father[x];
	}
}
//合并
void merge(int i, int j){
	int x = find(i);
	int y = find(j);
	if(x!=y){
		//按秩合并
		if(rank[x]<rank[y]){
			//这里总是让x的rank保持较大，y的rank保持较小
			int temp = x;
			x = y;
			y = temp;
		}
		father[y] = x;
		if(rank[x]==rank[y]){
			//这里不用判断合并后到底是rankx[x]++还是rank[y]++就是因为在上面我们总是让y合并在x上
			rank[x]++;
		}
	}
}

//这是一个内部类，因为kruskal算法是以边为基础的，这个类有助于方便的存储边的信息
class edge{
		//边的两个顶点
        int u;
        int v;
        //边的权值
        int value;
		//构造方法
        edge(int u, int v, int value){
            this.u = u;
            this.v = v;
            this.value = value;
        }
    }
	//kruskal算法具体实现
    public void  kruskal(int[][] G){
        //使用优先队列来保存所有的边的信息，并且以边的权值的升序排列
        PriorityQueue<edge> edges = new PriorityQueue<>(new Comparator<edge>() {
            @Override
            public int compare(edge o1, edge o2) {
                return o1.value - o2.value;
            }
        });
        //用来保存被加入到最小生成树中的边
        List<edge> minTree = new ArrayList<>();
        for(int i=0;i<G.length;i++){
            //因为这里构造的是所有边的集合，所以只需要遍历图的右上或左下部分，这里遍历的是左下部分
            for(int j=0;j<i;j++){
                if(G[i][j]!=0){
                    edges.add(new edge(i,j,G[i][j]));
                }
            }
        }
        //初始化并查集，这里注意并查集的工作是检测顶点是否属于一个联通分量，而不是检查边
        init(G.length);
        //记录添加到最小生成树中边的个数，当count>=G.length-1时，说明最小代价生成树已经构建完成
        int count = 0;
        while(!edges.isEmpty()){
        	//查找剩余边中权值最小边的两个顶点根节点
            int x = find(edges.peek().u);
            int y  =find(edges.peek().v);
            if(x!=y){
                minTree.add(edges.peek());
                count++;
                merge(edges.peek().u, edges.peek().v);
            }
            edges.remove();
            if(count>=G.length-1){
                break;
            }
        }
        for(edge e:minTree){
            System.out.println(e.u+" "+e.v);
        }
    }

测试用例：

//就是上述图中的用例
int[][] G = {
{0,10,7,0,0,4},
{10,0,0,0,2,0},
{7,0,0,8,0,6},
{0,0,8,0,9,5},
{0,2,0,9,0,7},
{4,0,6,5,7,0}};

结果（输出的是添加到最小代价生成树中的每一个边的两个顶点）：
4 1
5 0
5 3
5 2
5 4

kruskal适用于在边较少的图中有更高的效率