最小生成树

#include <iostream>
#include <algorithm>

using namespace std;

#define MAXVEX 20
#define MAXEDGE 20
#define INFINITY 65535

typedef struct
{
	int arc[MAXVEX][MAXVEX];
	int numVertexes, numEdges;
}MGraph;

typedef struct
{
	int begin;
	int end;
	int weight;
}Edge;

void CreateMGraph(MGraph *G)/* 构件图 */
{
	int i, j;

	/* printf("请输入边数和顶点数:"); */
	G->numEdges = 15;
	G->numVertexes = 9;

	for (i = 0; i < G->numVertexes; i++)/* 初始化图 */
	{
		for (j = 0; j < G->numVertexes; j++)
		{
			if (i == j)
				G->arc[i][j] = 0;
			else
				G->arc[i][j] = G->arc[j][i] = INFINITY;
		}
	}

	G->arc[0][1] = 10;
	G->arc[0][5] = 11;
	G->arc[1][2] = 18;
	G->arc[1][8] = 12;
	G->arc[1][6] = 16;
	G->arc[2][8] = 8;
	G->arc[2][3] = 22;
	G->arc[3][8] = 21;
	G->arc[3][6] = 24;
	G->arc[3][7] = 16;
	G->arc[3][4] = 20;
	G->arc[4][7] = 7;
	G->arc[4][5] = 26;
	G->arc[5][6] = 17;
	G->arc[6][7] = 19;

	for (i = 0; i < G->numVertexes; i++)
	{
		for (j = i; j < G->numVertexes; j++)
		{
			G->arc[j][i] = G->arc[i][j];
		}
	}

}

void MiniSpanTree_Prim(MGraph G)
{
	int i = 0, j,k;
	int lowcost[MAXVEX];
	int adjvex[MAXVEX];
	lowcost[0] = 0;
	adjvex[0] = 0;
	for (int i = 1; i < G.numVertexes; i++){
		lowcost[i] = G.arc[0][i];
		adjvex[i] = 0;
	}
	for (i = 1; i < G.numVertexes; i++){
		int min = INFINITY;
		k = 0;
		j = 1;
		while (j < G.numVertexes){
			if (lowcost[j] != 0 && lowcost[j] < min){
				min = lowcost[j];
				k = j;
			}
			j++;
		}
		printf("(%d,%d)\n", adjvex[k], k);
		lowcost[k] = 0;
		for (j = 1; j < G.numVertexes; j++){
			if (lowcost[j] != 0 && G.arc[k][j] < lowcost[j]){
				lowcost[j] = G.arc[k][j];
				adjvex[j] = k;
			}
		}
	}

}

bool cmp(Edge e1,Edge e2){
	return e1.weight < e2.weight;
}

int Find(int *parent,int x){
	int s = x;
	for (; parent[s] >= 0; s = parent[s]);
	while (s != x){//路径压缩
		int temp = parent[x];
		parent[x] = s;
		x = temp;
	}
	return s;
}

void Union(int *parent,int x,int y)
{
	int px = Find(parent, x);
	int py = Find(parent, y);
	int sum = parent[px] + parent[py];
	if (parent[px] > parent[py]){
		parent[py] = sum;
		parent[px] = py;
	}
	else{
		parent[px] = sum;
		parent[py] = px;
	}
}

void  kruskal(MGraph G)
{
	Edge edges[MAXEDGE];
	int k = 0;
	for (int i = 0; i < G.numVertexes-1; i++){
		for (int j = i+1; j < G.numVertexes; j++){
			if (G.arc[i][j] < INFINITY){
				edges[k].begin = i;
				edges[k].end = j;
				edges[k].weight = G.arc[i][j];
				k++;
			}
		}
	}
	sort(edges, edges + k, cmp);
	int parent[MAXVEX];
	for (int i = 0; i < G.numVertexes; i++){
		parent[i] = -1;
	}
	int num = 0;
	for (int i = 0; i < G.numEdges; i++){
		int begin = edges[i].begin;
		int end = edges[i].end;
		if (Find(parent,begin) != Find(parent,end)){
			printf("%d-%d:%d\n", begin, end, edges[i].weight);
			num++;
			Union(parent, begin, end);
		}
		if (num == G.numVertexes - 1)
			break;
	}
}

int main(void)
{
	MGraph G;
	CreateMGraph(&G);
	//MiniSpanTree_Prim(G);
	kruskal(G);
	system("pause");
	return 0;

}