图的最小生成树算法

两个均是贪心算法，均是先找最小边，再找次小边。重点在于如何判断是否形成回路。

Kruskal算法：解决方法，连通分量。O(n+eloge) 邻接表

仅适用于无向图。最小堆找出全局小边。通过检查边两端顶点是否在同一连通分量上来判断是否形成回路，若是，则舍弃，不是，则添加。

而判定连通分量通过并查集实现。如此循环N-1次，或者堆为空，则结束。

为什么Kruskal只适用于无向图？因为并查集判定连通分量是通过等价关系判定的，而有向图连通分量显然不满足等价关系。

上面方法也可以用来判定无向图中是否存在环路。

Prim算法：O(eloge)

有向图，无向图均可。通过是否是割边来判断回路。具体来说，通过一标记数组标记生成树节点，对于每个节点的向外割边，取最小边作为下一生成树边，

并将节点加入标记数组，更新割边，如此反复，直至覆盖所有顶点或者割边堆为空。

prim之所以适用于有向图是因为割边本身就是有向的。

下面给出Java代码：

Java中最小堆就是PriorityQueue.

并查集：

package com.company;
import java.util.ArrayList;
/**
 * Created by qiguo on 2017/4/6.
 */
public class UnionFindSet {
    ArrayList<Integer> arrayList;

    public UnionFindSet(){
        arrayList = new ArrayList<>(20);
        for (int i = 0; i < 20; i++) {
            arrayList.add(-1);
        }
    }

    /**
     * find the set that element belongs to
     * @param r element
     * @return set name
     */
    public int find(int r){
        int root = r;
        while (arrayList.get(root) > 0){
            root = arrayList.get(root);
        }
        return root;
    }

    /**
     * Union two set, the small set points to the large one
     * @param r1 set 1
     * @param r2 set 2
     */
    public void union(int r1, int r2){
        int p1 = find(r1);
        int p2 = find(r2);
        if (p1 == p2){
            return;
        }
        if (arrayList.get(p1) <= arrayList.get(p2)){
            arrayList.set(p1, arrayList.get(p1) + arrayList.get(p2));
            arrayList.set(p2,p1);
        }else {
            arrayList.set(p2, arrayList.get(p1) + arrayList.get(p2));
            arrayList.set(p1,p2);
        }
    }

}

图算法：

 public void kruskal(){
        PriorityQueue<Edge> edges = readEdge();
        UnionFindSet ufSet = new UnionFindSet();
        int count = numVertices - 1;
        while (!edges.isEmpty() && count > 0){
            Edge edge = edges.poll();
            if (ufSet.find(edge.v1) != ufSet.find(edge.v2)){
                ufSet.union(edge.v1, edge.v2);
                System.out.printf("(" + edge.v1 + ", " + edge.v2 + ") ");
                count--;
            }
        }
        System.out.println();
    }

    public void prim(){
        HashSet<Integer> resultSet = new HashSet<>();
        int count = 1;
        resultSet.add(0);
        PriorityQueue<Edge> edgePriorityQueue = new PriorityQueue<>();
        for (int i = 0; i < numVertices; i++) {
            if (graph[0][i] > 0 && graph[0][i] < 1000){
                Edge edge = new Edge(0, i, graph[0][i]);
                edgePriorityQueue.add(edge);
            }
        }
        while (!edgePriorityQueue.isEmpty() && count < numVertices){
            Edge tmp = edgePriorityQueue.poll();
            if (resultSet.contains(tmp.v2)){
                continue;
            }else {
                System.out.printf("(" + tmp.v1 + ", " + tmp.v2 + ") ");
                int node;
                if (resultSet.contains(tmp.v1)) {
                    node = tmp.v2;
                } else {
                    node = tmp.v1;
                }
                resultSet.add(node);
                count++;
                for (int i = 0; i < numVertices; i++) {
                    if (graph[node][i] > 0 && graph[node][i] < 1000 && !resultSet.contains(i)){
                        Edge edge = new Edge(node, i, graph[node][i]);
                        edgePriorityQueue.add(edge);
                    }
                }
            }
        }
    }