最小生成树 : Kruskal 算法

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Kruskal {
	static final int M = 10000;

	static class Edge implements Comparable<Edge> {
		char u;
		char v;
		int weight;

		public Edge(char u, char v, int weight) {
			this.u = u;
			this.v = v;
			this.weight = weight;
		}

		@Override
		public int compareTo(Edge o) {
			return weight < o.weight ? -1 : weight == o.weight ? 0 : 1;
		}
	}

	static int[] p;
	static int[] rank;

	static int find(int u) {
		while (p[u] != -1)
			u = p[u];
		return u;
	}

	static int kruskal(int vertex, List<Edge> edges) {
		Collections.sort(edges);

		// MAKE-SET
		p = new int[vertex];
		rank = new int[vertex];
		for (int i = 0; i < vertex; i++) {
			p[i] = -1;
			rank[i] = 0;
		}

		int cnt = vertex - 1;
		int cost = 0;
		for (Edge edge : edges) {
			if (edge.weight == M)
				break;

			int u = edge.u - 'A';
			int v = edge.v - 'A';
			// FIND-SET
			int ru = find(u);
			int rv = find(v);
			if (ru != rv) {
				System.out.printf("%c - %c : %d\n", edge.u, edge.v, edge.weight);
				cost += edge.weight;
				
				// UNION
				if (rank[ru] > rank[rv]) {
					p[rv] = ru;
				} else {
					p[ru] = rv;
					if (rank[ru] == rank[rv])
						rank[rv]++;
				}
				
				cnt--;
				if (cnt == 0)
					break;
			}
		}
		return cost;
	}

	public static void main(String[] args) {
		int vertex = 7;
		List<Edge> edges = new ArrayList<Kruskal.Edge>();
		edges.add(new Edge('A', 'B', 7));
		edges.add(new Edge('A', 'D', 5));
		edges.add(new Edge('B', 'C', 8));
		edges.add(new Edge('B', 'D', 9));
		edges.add(new Edge('B', 'E', 7));
		edges.add(new Edge('C', 'E', 5));
		edges.add(new Edge('D', 'E', 15));
		edges.add(new Edge('D', 'F', 6));
		edges.add(new Edge('E', 'F', 8));
		edges.add(new Edge('E', 'G', 9));
		edges.add(new Edge('F', 'G', 11));

		int mst = kruskal(vertex, edges);
		System.out.println("MST Kruskal cost:" + mst);
	}
}

输出：

 A - D : 5
C - E : 5
D - F : 6
A - B : 7
B - E : 7
E - G : 9
MST Kruskal cost:39