C++——算法基础之最小生成树（Prim 和 Kruskal）

今天，大白跟大家分享一下最小生成树算法。

最小生成树算法有两种：Prim算法 和 Kruskal算法

Prim算法：以顶点为基础的向外扩张，从某一顶点（A）开始，依次寻找未知顶点中（未加入最小生成树的顶点）到已知顶点的最小权值的顶点。直到找到包含（A）的最大连通图中的所有顶点为止。（由此可见，从不同的顶点开始，获得的最小生成树也就不同，当把图中的每个顶点都建立最小生成树后，就获得了所谓的生成森林）。

所以，其适用于稠密图（顶点少于边）。

图例	说明	不可选	可选	已选（Vnew）
	此为原始的加权连通图。每条边一侧的数字代表其权值。	-	-	-
	顶点D被任意选为起始点。顶点A、B、E和F通过单条边与D相连。A是距离D最近的顶点，因此将A及对应边AD以高亮表示。	C, G	A, B, E, F	D
	下一个顶点为距离D或A最近的顶点。B距D为9，距A为7，E为15，F为6。因此，F距D或A最近，因此将顶点F与相应边DF以高亮表示。	C, G	B, E, F	A, D
	算法继续重复上面的步骤。距离A为7的顶点B被高亮表示。	C	B, E, G	A, D, F
	在当前情况下，可以在C、E与G间进行选择。C距B为8，E距B为7，G距F为11。E最近，因此将顶点E与相应边BE高亮表示。	无	C, E, G	A, D, F, B
	这里，可供选择的顶点只有C和G。C距E为5，G距E为9，故选取C，并与边EC一同高亮表示。	无	C, G	A, D, F, B, E
	顶点G是唯一剩下的顶点，它距F为11，距E为9，E最近，故高亮表示G及相应边EG。	无	G	A, D, F, B, E, C
	现在，所有顶点均已被选取，图中绿色部分即为连通图的最小生成树。在此例中，最小生成树的权值之和为39。	无	无	A, D, F, B, E, C, G

（此图是盗用他人的，别的好东西有助于我们更好的理解，所以就利用利用了哈^_^）

Kruskal算法：以边为基础的向内收拢，首先将所有边进行升序排序，然后从最小边开始，判断当前边的顶点是否已经在最小生成树中，若是，则舍弃该边继续，否则，将该边加入到最小生成树中。直到所有边都遍历完成。（在判断时，用到一个并查集）。（我暂时获得的是生成森林喔*_*）

其适用于稀疏图（即边较少）。

图例描述：

首先第一步，我们有一张图Graph，有若干点和边 

 

将所有的边的长度排序，用排序的结果作为我们选择边的依据。这里再次体现了贪心算法的思想。资源排序，对局部最优的资源进行选择，排序完成后，我们率先选择了边AD。这样我们的图就变成了右图

 

 

 

在剩下的变中寻找。我们找到了CE。这里边的权重也是5

依次类推我们找到了6,7,7，即DF，AB，BE。

下面继续选择， BC或者EF尽管现在长度为8的边是最小的未选择的边。但是现在他们已经连通了（对于BC可以通过CE,EB来连接，类似的EF可以通过EB,BA,AD,DF来接连）。所以不需要选择他们。类似的BD也已经连通了（这里上图的连通线用红色表示了）。

最后就剩下EG和FG了。当然我们选择了EG。最后成功的图就是右：

 

（此图是盗用他人的，别的好东西有助于我们更好的理解，所以就利用利用了哈^_^）

代码如下：

Prim:

#include <iostream>
using namespace std;

#define MaxNum 20
#define MaxEdge 190
#define MAX 32767

struct MGraph
{
	char Vertex[MaxNum];
	int Edge[MaxNum][MaxNum];
	int n, e;
};

struct closedge			//辅助数组，存储从集合U到集合V-U中各顶点的权值最小边
{
	int adjvex;
	int lowcost;
}closedge[MaxNum];


int locate_vex (MGraph *G, char ver)
{
	for(int i = 0; i < G->n; i++)
	{
		if(G->Vertex[i] == ver)
		{
			return i;
		}
	}
	return -1;
}

void creatgraph (MGraph *G)
{
	int i, j, k, cost;
	char vex1, vex2;
	cout << "请输入网的顶点名称：";
	for(i = 0; i < G->n; i++)
	{
		cin >> G->Vertex[i];
	}
	for(i = 0; i < G->n; i++)
	{
		for(j = 0; j < G->n; j++)
		{
			G->Edge[i][j] = MAX;
		}
	}
	cout << "请输入网中每条边所依附的顶点信息：";
	for(k = 0; k < G->e; k++)
	{
		cout << "\n请输入第 " << k + 1 << " 条边的第一个顶点信息：";
		cin >> vex1;
		cout << "请输入第 " << k + 1 << " 条边的第二个顶点信息：";
		cin >> vex2;
		i = locate_vex (G, vex1);
		j = locate_vex (G, vex2);
		cout << "请输入第 " << k + 1 << " 条边的权值：";
		cin >> cost;
		G->Edge[i][j] = G->Edge[j][i] = cost;
	}
}

void Prim (MGraph *G)
{
	int i, j, k;
	int mincost;
	char vex;
	cout << "\n请输入构造最小生成树的起始顶点：";
	cin >> vex;
	k = locate_vex (G, vex);
	cout << "其余顶点为：";
	for(i = 0; i < G->n; i++)
	{
		if(i != k)
		{
			closedge[i].adjvex = k;
			closedge[i].lowcost = G->Edge[k][i];
		}
	}
	closedge[k].lowcost = 0;
	closedge[k].adjvex = k;
	for(i = 0; i < G->n - 1; i++)
	{
		mincost = MAX;
		j = 0;
		k = 0;
		while(j < G->n)
		{
			if(closedge[j].lowcost < mincost && closedge[j].lowcost != 0)
			{
				mincost = closedge[j].lowcost;
				k = j;
			}
			j++;
		}
		cout << "\n顶点 " << G->Vertex[k] << " 边的权值为：" << mincost;
		closedge[k].lowcost = 0;
		for(j = 0; j < G->n; j++)
		{
			if(G->Edge[k][j] < closedge[j].lowcost)
			{
				closedge[j].lowcost = G->Edge[k][j];
				closedge[j].adjvex = k;
			}
		}
	}
}

void outputgraph (MGraph *G)
{
	for(int i = 0; i < G->n; i++)
	{
		cout << "\t" << G->Vertex[i];
	}
	cout << endl << endl;
	for(int i = 0; i < G->n; i++)
	{
		cout << G->Vertex[i];
		for(int j = 0; j < G->n; j++)
		{
			if(G->Edge[i][j] == MAX)
			{
				cout << "\t" << "∞";
			}
			else
			{
				cout << "\t" << G->Edge[i][j];
			}
		}
		cout << endl << endl;
	}
}

int main28 ()
{
	MGraph mg;
	cout << "以 Prim 算法构造无向连通网的最小生成树......";
	cout << "\n请输入连通网的顶点数目和边数，以空格‘ ’分隔开：";
	cin >> mg.n >> mg.e;
	creatgraph (&mg);
	outputgraph (&mg);
	Prim (&mg);
	return 0;
}

Kruskal:

#include <iostream>
using namespace std;

#define INF 10000
#define MAX 20
#define MAXE 100

struct MyGraph
{
	int vNum;
	int eNum;
	int vexs[MAX];
	int edges[MAX][MAX];
};

struct edgeArray
{
	int v1, v2, w;
};

edgeArray edgearr[MAX];

int getVerIndex (int ver)
{
	return ver - 1;
}

void createMygGraph (MyGraph *mg)
{
	cout << "请输入图的顶点数和边数：";
	cin >> mg->vNum >> mg->eNum;
	cout << "顶点：";
	for(int i = 0; i < mg->vNum; i++)
	{
		cin >> mg->vexs[i];
	}
	for(int i = 0; i < mg->vNum; i++)
	{
		for(int j = 0; j < mg->vNum; j++)
		{
			mg->edges[i][j] = INF;
		}
	}
	int v1, v2, w;
	for(int i = 0; i < mg->eNum; i++)
	{
		cout << "边" << i + 1 << " 的顶点1，顶点2，权值：";
		cin >> v1 >> v2 >> w;
		int index1 = getVerIndex (v1);
		int index2 = getVerIndex (v2);
		mg->edges[index1][index2] = mg->edges[index2][index1] = w;
		edgearr[i].v1 = v1;
		edgearr[i].v2 = v2;
		edgearr[i].w = w;
	}
}

void sortEdge (MyGraph * mg)
{
	for(int i = 1; i < mg->eNum; i++)
	{
		bool flag = true;
		for(int j = 0; j < mg->eNum - i; j++)
		{
			if(edgearr[j].w > edgearr[j + 1].w)
			{
				edgeArray temp;
				temp.v1 = edgearr[j].v1;
				temp.v2 = edgearr[j].v2;
				temp.w = edgearr[j].w;

				edgearr[j].v1 = edgearr[j + 1].v1;
				edgearr[j].v2 = edgearr[j + 1].v2;
				edgearr[j].w = edgearr[j + 1].w;

				edgearr[j + 1].v1 = temp.v1;
				edgearr[j + 1].v2 = temp.v2;
				edgearr[j + 1].w = temp.w;

				flag = false;
			}
		}
		if(flag)
		{
			break;
		}
	}
}

int father[MAX];

int find (int x)
{
	if(x != father[x])
	{
		father[x] = find (father[x]);
	}
	return father[x];
}

void Kruskal (MyGraph *mg)
{
	cout << "最小生成树为：\n";
	int j = 0;
	for(int k = 0; k < mg->vNum; k++)
	{
		father[k] = k;
	}
	while(j < mg->eNum)
	{
		int v1 = edgearr[j].v1;
		int v2 = edgearr[j].v2;
		v1 = find (v1);
		v2 = find (v2);
		if(v1 != v2)
		{
			cout << "<" << edgearr[j].v1 << "," << edgearr[j].v2 << "> : " << edgearr[j].w << "\t";
			father[v1] = v2;
		}
		j++;
	}
	cout << endl;
}

void printGraph (MyGraph *mg)
{
	for(int i = 0; i < mg->vNum; i++)
	{
		cout << "\t" << mg->vexs[i];
	}
	cout << endl << endl;
	for(int i = 0; i < mg->vNum; i++)
	{
		cout << mg->vexs[i];
		for(int j = 0; j < mg->vNum; j++)
		{
			if(INF == mg->edges[i][j])
			{
				cout << '\t' << "∞";
			}
			else
			{
				cout << '\t' << mg->edges[i][j];
			}
		}
		cout << endl << endl;
	}
}

int main()
{
	MyGraph mg;
	createMygGraph (&mg);
	printGraph (&mg);
	sortEdge (&mg);
	Kruskal (&mg);
	return 0;
}