最小生成树

最小生成树：
* 在整个图连通的情况下，保证所有边的权值之和最小，找出这个图

 

1.Kruskal算法：

* Kruskal算法思路：
* 将边从小到大进行排列，然后在加入边时，看边的两个端点是否已经连通，若连通，则不加这条边，直接检查下一条边
* 若不连通，则加上这条边，并把边上的点设为连通的状态.
*
* 而判断边连不连通则是看这两条边在不在同一组(所以使用并查集来进行对分组合并问题的实现)

 

代码及解析：

//先写好点的并查集结构
    public static class UnionFinds {
        public HashMap<Node,Node> fatherMap;//记录边的父亲(所在分组)
        public HashMap<Node,Integer> rankMap;//记录边所在的层级
        
        public UnionFinds(Graph g) {
            for (Node node : g.nodeis) {
                fatherMap.put(node, node);//一开始把自己做为祖先
                rankMap.put(node, 1);
            }
        }
        
        public Node find(Node e) {
            if (e != fatherMap.get(e)) {
                fatherMap.put(e, find(e));
            }
            return fatherMap.get(e);
        }
        
        public boolean Union(Node a,Node b) {
            Node rootA = find(a);
            Node rootB = find(b);
            if (rootA == rootB) {
                return false;
            }
            if (rankMap.get(rootA) < rankMap.get(rootB)) {
                fatherMap.put(a, rootB);
            }
            else {
                fatherMap.put(b, rootA);
                if (rankMap.get(rootA) == rankMap.get(rootB)) {
                    rankMap.put(rootA, rankMap.get(rootA) + 1);
                }
            }
            return true;
        }
        
        public boolean isSame(Node a,Node b) {
            return find(a) == find(b);
        }
    }

 

执行实现Kruskal算法：

public static class EdgeComparator implements Comparator<Edge> {
        public int compare(Edge e1,Edge e2) {
            return e1.weight - e2.weight;
        }
    }
    
    public static Set<Edge> Kruskals(Graph g) {
        UnionFinds unionFind = new UnionFinds(g);
        PriorityQueue<Edge> pq = new PriorityQueue<>(new EdgeComparator());
        for (Edge edge : g.edges) {
            pq.add(edge);
        }
        Set<Edge> set = new HashSet<>();
        while (pq.size() > 0) {
            Edge e = pq.poll();
            if (!unionFind.isSame(e.from, e.to)) {
                unionFind.Union(e.from, e.to);
                set.add(e);
            }
        }
        return set;
    }

 

2.Prim算法：

* 1.从第一个点(把该点存入点集)出发，将所有与这个点相连的边都加入到选择边集中，从中找出最短的边
* 如果这条边的两端都在点集中，则继续往下找，直到找到两端有一端不在点集中时，将这条边引入答案边集，并
* 把边的两端都引入点集(实际只加了一端，另一端已经存在)
* 2.将新点引入后，如果点集中已有全部的点，则直接结束操作。否则，新点又会带来若干条新边，
* 将所有的新边引入到选择边集后，重新回到1操作

 

public static class EdgeComparator implements Comparator<Edge> {
        public int compare(Edge e1,Edge e2) {
            return e1.weight - e2.weight;
        }
    }
    
    public static Set<Edge> Prims(Graph g) {
        PriorityQueue<Edge> pq = new PriorityQueue<>(new EdgeComparator());//选择边集
        HashSet<Node> nodes = new HashSet<>();//存入已被连通的点集
        HashSet<Edge> results = new HashSet<>();//答案边集
        
        for (Node node : g.nodes.values()) {//随机选一个点，做为操作的起始点
            
            if (!nodes.contains(node)) {//如果这个点不在已被连通的点集中
                nodes.add(node);
                for (Edge edge : node.edges) {//先对优先队列初始化，把初始点的连通边都加到队列中
                    pq.add(edge);
                }
                while (pq.size() > 0) {//等优先队列所有的边都被清空后结束
                    Edge edge = pq.poll();//弹出来的边不一定符合条件
                    Node toNode = edge.to;
                    if (!nodes.contains(toNode)) {//一定保证to节点不在已被连通点集中，才加入这条边
                        results.add(edge);//这条边即所要的其中一条边，加入到答案
                        nodes.add(toNode);//加完这条边，该点就在连通点集中
                    }
                    for (Edge e : toNode.edges) {//把新加的点的相连边都加入到选择边集中去
                        pq.add(e);
                    }
                }
            }
        }
        return results;
    }