图的应用（一）——最小生成树
最重要的Kruskal和Prime算法，先理解，后期可以选择记忆。
一、最小生成树
先明白生成树的概念:对连通图进行遍历，过程中所经过的边和顶点的组合可看做是一棵普通树，通常称为生成树。
那么，在连通网的所有生成树中，所有边的代价和最小的生成树，称为最小生成树（MST）。
如下图所表示：
二、克鲁斯卡尔算法(Kruskal算法)求最小生成树
Kruskal算法特点：将边归并，故名“加边法”，适于求稀疏网的最小生成树。
实例看步骤：
运用Java代码实现：
import java.util.ArrayList;
import java.util.Collections;
public class Kruskal {
public static void main(String[] args) {
int[][] edges = {
{0, 1, 6},
{0, 2, 1},
{0, 3, 5},
{2, 1, 5},
{2, 3, 5},
{2, 4, 5},
{2, 5, 4},
{1, 4, 3},
{4, 5, 6},
{5, 3, 2}
};
int n = 6; //结点个数
int[][] mstEdges = kruskal(n, edges);
int totalCost = 0;
System.out.println("Edges of MST: [node1, node2, cost]");
//输出构树的边集
for (int i = 0; i < mstEdges.length; i++) {
int[] edge = mstEdges[i];
for (int j = 0; j < edge.length; j++) {
System.out.print(edge[j] + " ");
}
totalCost += edge[2];
System.out.println();
}
System.out.println("Total cost of MST: " + totalCost); //求最小生成树权数
}
public static int[][] kruskal(int n, int[][] edges) {
/**
* @Description: 克鲁斯卡尔算法求最小生成树
* @Param: [n, edges] ==> [结点个数， 边集]
* @return: int[] 构成最小生成树的边集
* @Author: 借鉴CSDN作者Aiven
*/
int[] pres = new int[n]; //并查集
int[] ranks = new int[n]; //结点的秩
// 初始化：pres一开始设置每个元素的上一级是自己，ranks一开始设置每个元素的秩为0
for (int i = 0; i < n; i++) {
pres[i] = i;
ranks[i] = 0;
}
//用自己定义的MyEdge类里面的compareTo排序，按边权排序
ArrayList<MyEdge> edgesList = new ArrayList<>();
for (int i = 0; i < edges.length; i++) {
edgesList.add(new MyEdge(edges[i]));
}
// 边集从小到大排序
Collections.sort(edgesList);
int[][] mstEdges = new int[n - 1][3];
int count = 0;
for (int i = 0; i < edgesList.size(); i++) {
int[] arr = edgesList.get(i).array;
int a = arr[0], b = arr[1], c = arr[2];
if (find(a, pres) != find(b, pres)) {
unionSet(a, b, pres, ranks);
mstEdges[count] = arr;
count++;
}
if (count == n) {
break;
}
}
return mstEdges;
}
//并：合并两个集合，按秩合并
public static void unionSet(int n1, int n2, int[] pres, int[] ranks) {
int root1 = find(n1, pres);
int root2 = find(n2, pres);
//当两个元素不是同一组的时候才合并
if (root1 != root2) {
if (ranks[root1] < ranks[root2]) {
pres[root1] = root2;
} else {
pres[root2] = root1;
if (ranks[root1] == ranks[root2])
ranks[root1]++;
}
}
}
//查：查找元素的首级
public static int find(int x, int[] pres) {
int root = x;
while (pres[root] != root)
root = pres[root];
//路径压缩
int p = x;
while (pres[p] != p) {
int t = pres[p];
pres[p] = root;
p = t;
}
return root;
}
}
// 边的排序类
class MyEdge implements Comparable {
int[] array;
MyEdge(int[] array) {
this.array = array;
}
@Override
public int compareTo(Object o) {
o = (MyEdge) o;
int[] arr = ((MyEdge) o).array;
if (array[2] > arr[2]) {
return 1;
} else if (array[2] == arr[2]) {
return 0;
} else {
return -1;
}
}
}
// output:
//
// Edges of MST: [node1, node2, cost]
// 0 2 1
// 5 3 2
// 1 4 3
// 2 5 4
// 2 1 5
// 0 0 0
// Total cost of MST: 15
程序图解：
三、普里姆算法(Prim算法)求最小生成树
Prime算法特点：将顶点归并，故名“加点法”，与变数无关，适于稠密图。
实例看步骤：
运用Java代码实现：
/**
* 最小生成树的prim算法
* @author 借鉴博客园作者liuy
*/
public class Prim {
public static void prim(int num, float[][] weight) { //num为顶点数，weight为权
float[] lowcost = new float[num + 1]; //到新集合的最小权
int[] closest = new int[num + 1]; //代表与s集合相连的最小权边的点
boolean[] s = new boolean[num + 1]; //s[i] == true代表i点在s集合中
s[1] = true; //将第一个点放入s集合
for(int i = 2; i <= num; i++) { //初始化辅助数组
lowcost[i] = weight[1][i];
closest[i] = 1;
s[i] = false;
}
for(int i = 1; i < num; i++) {
float min = Float.MAX_VALUE;
int j = 1;
for(int k = 2; k <= num; k++) {
if((lowcost[k] < min) && (!s[k])) {//根据最小权加入新点
min = lowcost[k];
j = k;
}
}
//新加入点的j和与j相连的点
System.out.println("加入点" + j + ". " + j + "---" + closest[j]);
s[j] = true;//加入新点j
for(int k = 2; k <= num; k++) {
if((weight[j][k] < lowcost[k]) && !s[k]) {//根据新加入的点j,求得最小权
lowcost[k] = weight[j][k];
closest[k] = j;
}
}
}
}
public static void main(String[] args) {
float m = Float.MAX_VALUE;
//该图的矩阵
float[][] weight = {{0, 0, 0, 0, 0, 0, 0},
{0, m, 6, 1, 5, m, m},
{0, 6, m, 5, m, 3, m},
{0, 1, 5, m, 5, 6, 4},
{0, 5, m, 5, m, m, 2},
{0, m, 3, 6, m, m, 6},
{0, m, m, 4, 2, 6, m}};
prim(weight.length - 1, weight);
}
}
// output:
//
//加入点3. 3---1
//加入点6. 6---3
//加入点4. 4---6
//加入点2. 2---3
//加入点5. 5---2
//自行算出权值15
程序图解：
四、C语言核心代码
代码学习于王道数据结构，仅供参考。
1、Kruskal
#define MaxSize 100
typedef struct {
int a,b; //边的两个顶点
int weight; //边的权值
}Edge; //边结构体
int Find(int *parent,int x){
while(parent[x]>=0) x=parent[x]; //循环向上寻找下标为x顶点的根
return x; //while循环结束时找到了根的下标
}
Edge edges[MaxEdge]; //边数组
int parent[MaxVex]; //父亲顶点数组(并查集)
void MiniSpanTree_Kruskal(MGraph G){
int i , n , m;
sort(edges); //按权值由小到大对边排列
for(i=0 ; i<G.vexnum ; i++)parent[i]=-1; //初始化：各个顶点单独形成一个集合
for(i=0 ; i<G.arcnum ; i++){ //扫描每条边
n=Find(parent,edges[i].a); //n是这条边的第一个顶点的根顶点所在下标
m=Find(parent,edges[i].b); //m是这条边第二个顶点的根顶点所在下标
if(n!=m){ //根顶点不相同 这条边不会构成环
parent[n]=m; //并操作
//作为生成树的一条边打印出来
printf(“(%d->%d) ”,edges[i].a,edges[i].b);
}
}
}
Kruskal算法操作分为对边的权值排序部分和一个单重for循环，它们是并列关系，由于排序耗费时间大于单重循环，所以克鲁斯卡尔算法的主要时间耗费在排序上。排序和图中边的数量有关系，所以适合稀疏图。
2、Prim
void MiniSpanTree_Prim(MGraph G){
int min,i,j,k;
int adjvex[MAXVEX]; //保存邻接顶点下标的数组
int lowcost[MAXVEX]; //记录当前生成树到剩余顶点的最小权值
lowcost[0]=0; //将0号顶点(以0号顶点作为第一个顶点)加入生成树
adjvex[0]=0; //由于刚开始生成树只有一个顶点 不存在边 干脆都设为0
for(i=1;i<G.vexnum;i++){ //除下标为0以外的所有顶点
lowcost[i]=G.arc[0][i]; //将与下标为0的顶点有边的权值存入Lowcost数组
adjvex[i]=0; //这些顶点的adjvex数组全部初始化为0
}
//算法核心
for(i=1;i<G.vexnum;i++){//只需要循环N-1次，N为顶点数
min=65535; //tip：因为要找最小值，不妨先设取一个最大的值来比较
j=0;k=0;
//找出lowcost最小的 最小权值给min，下标给k
while(j<G.vexnum){ //从1号顶点开始找
if(lowcost[j]!=0 && lowcost[j]<min){
//不在生成树中的顶点而且权值更小的
min=lowcost[j]; //更新更小的值
k=j; //找到了新的点下标给k
}
j++; //再看下一个顶点
}
printf(“(%d->%d)”,adjvex[k],k); //打印权值最小的边
lowcost[k]=0; //将这个顶点加入生成树
//生成树加入了新的顶点 从下标为1的顶点开始更新lowcost数组值
for(j=0;j<G.vexnum;j++){
if(lowcost[j]!=0 && G.arc[k][j]<lowcost[j]){
//如果新加入树的顶点k使得权值变小
lowcost[j]=G.arc[k][j]; //更新更小的权值
adjvex[j]=k;
//修改这条边邻接的顶点 也就是表示这条边是 从选出的顶点k指过来的 方便打印
}
}
}
}
双重循环，外层循环次数为n-1，内层并列的两个循环次数都是n。故普利姆算法时间复杂度为O(n²)而且时间复杂度只和n有关，所以适合稠密图。
