最小生成树--Kruskal算法

条件：无向图

从边开始，将所有边加到优先级队列里面，依次弹出，如果该边起点和终点不是在同一个并查集里面，就将该边加到结果集合里面，并且将这两个点合并到同一个并查集里

图的表示和生成见：​​点击打开链接​​

import java.util.Collection;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.PriorityQueue;
import java.util.Set;
public class Kruskal {
  // Union-Find Set--并查集
  public static class UnionFind {
    private HashMap<Node, Node> fatherMap;
    private HashMap<Node, Integer> rankMap;

    public UnionFind() {
      fatherMap = new HashMap<Node, Node>();
      rankMap = new HashMap<Node, Integer>();
    }

    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<Node> 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<Edge> {

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

  }
  //最小生成树算法--kruskal
  public static Set<Edge> kruskalMST(Graph graph) {
    UnionFind unionFind = new UnionFind();
    unionFind.makeSets(graph.nodes.values());//每一个点都是并查集的一个小的集合
    PriorityQueue<Edge> priorityQueue = new PriorityQueue<>(new EdgeComparator());
    for (Edge edge : graph.edges) {//将所有边加入到优先级队列里面
      priorityQueue.add(edge);
    }
    Set<Edge> result = new HashSet<>();
    while (!priorityQueue.isEmpty()) {
      Edge edge = priorityQueue.poll();//堆里弹出边权重最小的边
      if (!unionFind.isSameSet(edge.from, edge.to)) {//如果边的from点和to点都在集合里面了，就不要这个边
        //否则就加到ersult集合并且将该边放到并查集里
        result.add(edge);
        unionFind.union(edge.from, edge.to);
      }
    }
    return result;
  }
}