最小生成树Kruskal算法-java实现（使用并查集结构）

最小生成树Kruskal算法-java实现（使用并查集结构）

克鲁斯卡尔算法百度到的解释是：克鲁斯卡尔算法是一种用来寻找最小生成树的算法。在剩下的所有未选取的边中，找最小边，如果和已选取的边构成回路，则放弃，选取次小边。

1.将图的所有连接线去掉，只剩顶点

2.从图的边集数组中找到权值最小的边，将边的两个顶点连接起来

3.继续寻找权值最小的边，将两个顶点之间连接起来，如果选择的边使得最小生成树出现了环路，则放弃该边，选择权值次小的边

4.直到所有的顶点都被连接在一起并且没有环路，最小生成树就生成了。

具体的过程的解析在代码中都已经详细的注释了，包括并查集结构的使用，这里用到了自己定义的比较器来利用优先级队列实现小根堆，小根堆的作用是根据边的权值的大小进行排序。
代码如下：

import java.util.Collection;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.PriorityQueue;
import java.util.Set;

//undirected graph only
public class Code_04_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;//自己定义的比较器实现小根堆
		}

	}

	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;
	}
}