最小生成树

最小生成树要求：

首先，保证所有点连通，其次保证边的权重和最低
应用范围：无向图

Kruskal（克鲁斯卡尔）算法：

思路：

依次找权值最小的边，直到遍历完边并且不形成环为止。
实现方法用的并查集，首先把图的所有变放到一个小根堆里，然后从小根堆poll，判断poll出的边edge的fromNode和toNode在不在并查集里，即他们的父节点是不是一样的，如果一样就说明形成环了，如果没有就把这两个点加入到并查集合里，执行直到小根堆为空

代码：

    public static class UnionFind {
                //key 当前结点 value 父节点
        private HashMap fatherMap;
                //当前集合的大小（最后就用头节点的大小来表示，size存在头节点中）
        private HashMap rankMap;

        public UnionFind() {
            fatherMap = new HashMap();
            rankMap = new HashMap();
        }

        private Node findFather(Node n) {
            Node father = fatherMap.get(n);
            if (father != n) {
                father = findFather(father);
            }
            fatherMap.put(n, father);
            return father;
        }

        public void makeSets(Collection nodes) {
            fatherMap.clear();
            rankMap.clear();
            for (Node node : nodes) {
                fatherMap.put(node, node);
                rankMap.put(node, 1);
            }
        }

        public boolean isSameSet(Node a, Node b) {
            return findFather(a) == findFather(b);
        }

        public void union(Node a, Node b) {
            if (a == null || b == null) {
                return;
            }
            Node aFather = findFather(a);
            Node bFather = findFather(b);
            if (aFather != bFather) {
                int aFrank = rankMap.get(aFather);
                int bFrank = rankMap.get(bFather);
                if (aFrank <= bFrank) {
                    fatherMap.put(aFather, bFather);
                    rankMap.put(bFather, aFrank + bFrank);
                } else {
                    fatherMap.put(bFather, aFather);
                    rankMap.put(aFather, aFrank + bFrank);
                }
            }
        }
    }

    public static class EdgeComparator implements Comparator {

        @Override
        public int compare(Edge o1, Edge o2) {
            return o1.weight - o2.weight;
        }

    }

    public static Set kruskalMST(Graph graph) {
        UnionFind unionFind = new UnionFind();
        unionFind.makeSets(graph.nodes.values());
        PriorityQueue priorityQueue = new PriorityQueue<>(new EdgeComparator());
        for (Edge edge : graph.edges) {
            priorityQueue.add(edge);
        }
        Set result = new HashSet<>();
        while (!priorityQueue.isEmpty()) {
            Edge edge = priorityQueue.poll();
            if (!unionFind.isSameSet(edge.from, edge.to)) {
                result.add(edge);
                unionFind.union(edge.from, edge.to);
            }
        }
        return result;
    }

Prim（普里姆）算法：

思路：

创建一个优先级队列（小根堆），创建一个Hashset set用来存已经经过的节点，再创建一个Set result 来存结果边，从所有节点中随机选一个节点，判断该节点是否在set里，如果不在就加入，然后把当前node的所有的边加入到优先级队列，然后弹出小根堆的堆顶，即当前节点所连边权值最小的那一条，然后判断这条边所连的节点toNode，是否在set中如果不在，就加入，同时把边加入到result中，然后再把toNode所连的所有边加入到优先级队列（小根堆里），依次执行下去，得出结果。
总结起来一句话：随机找一个节点，通过这个节点找权值最小的边，通过这条边再找节点，节点如果没遍历，就继续从这个节点找权值最小的边，最后结束。

代码：

    public static class EdgeComparator implements Comparator {

        @Override
        public int compare(Edge o1, Edge o2) {
            return o1.weight - o2.weight;
        }

    }

    public static Set primMST(Graph graph) {
        PriorityQueue priorityQueue = new PriorityQueue<>(new EdgeComparator());
        HashSet set = new HashSet<>();
        Set result = new HashSet<>();
        for (Node node : graph.nodes.values()) {
            if (!set.contains(node)) {
                set.add(node);
                for (Edge edge : node.edges) {
                    priorityQueue.add(edge);
                }
                while (!priorityQueue.isEmpty()) {
                    Edge edge = priorityQueue.poll();
                    Node toNode = edge.to;
                    if (!set.contains(toNode)) {
                        set.add(toNode);
                        result.add(edge);
                        for (Edge nextEdge : toNode.edges) {
                            priorityQueue.add(nextEdge);
                        }
                    }
                }
            }
        }
        return result;
    }

注意：代码上的最开始的超级循环是用来处理森林的问题，比如一个图有森林（森林：n棵互不相交的树），你第一次选的起始点遍历完后，就只能处理一棵树，第二棵没有处理，所以这时候遍历所有节点结合判断set里是否有遍历的当前node，即可完成所有树的最小生成树的查找。