最小生成树要求：
首先，保证所有点连通，其次保证边的权重和最低
应用范围：无向图
Kruskal（克鲁斯卡尔）算法：
思路：
依次找权值最小的边，直到遍历完边并且不形成环为止。
实现方法用的并查集，首先把图的所有变放到一个小根堆里，然后从小根堆poll，判断poll出的边edge的fromNode和toNode在不在并查集里，即他们的父节点是不是一样的，如果一样就说明形成环了，如果没有就把这两个点加入到并查集合里，执行直到小根堆为空
代码：
public static class UnionFind {
//key 当前结点 value 父节点
private HashMap<Node, Node> fatherMap;
//当前集合的大小（最后就用头节点的大小来表示，size存在头节点中）
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;
}
}
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)) {
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<Edge> {
@Override
public int compare(Edge o1, Edge o2) {
return o1.weight - o2.weight;
}
}
public static Set<Edge> primMST(Graph graph) {
PriorityQueue<Edge> priorityQueue = new PriorityQueue<>(new EdgeComparator());
HashSet<Node> set = new HashSet<>();
Set<Edge> 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，即可完成所有树的最小生成树的查找。
