克鲁斯卡尔算法：

【1】克鲁斯卡尔算法

普里姆算法是以某顶点为起点，逐步找各顶点上最小权值的边来构建最小生成树。

克鲁斯卡尔算法是直接以边为目标去构建。

因为权值是在边上，直接去找最小权值的边来构建生成树也是很自然的想法，只不过构建时要考虑是否会形成环路而已。

此时我们用到了图的存储结构中的边集数组结构。

以下是边集数组结构的定义代码：

本算法所用同普里姆算法的实例，我们直接创建图的边集数组。

并对边的权值从小到大排序后如下图：

【2】克鲁斯卡尔算法及详解

克鲁斯卡尔算法及其详解：

鉴于此算法很简单，当 i=0, i=1, i=2时执行结果可以眼观，不再赘述。直接分析重点：

此算法的Find函数由边数e决定，时间复杂度为O(loge),而外面有一个for循环e次。

所以克鲁斯卡尔算法的时间复杂度为O(eloge)

对比两个算法：

克鲁斯卡尔算法主要针对边展开，边数少时效率会很高，所以对于稀疏图有优势

而普利姆算法对于稠密图，即边数非常多的情况会好些。

【3】克鲁斯卡尔算法实现

实现代码如下：

/克鲁斯卡尔算法

//在连通网中求出最小生成树

#include

#include

#define MAXEDGE 20

#define MAXVEX 20

#define INFINITY 65535

typedef struct

{

int arc[MAXVEX][MAXVEX];

int numVertexes, numEdges;//顶点数，边数

}MGraph;

typedef struct

{

int begin;

int end;

int weight;

}Edge; //对边集数组Edge结构的定义

//创建图的邻接矩阵

void CreateMGraph(MGraph *G) {

int i, j;

G->numEdges=11;

G->numVertexes=7;

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]=7;

G->arc[0][3]=5;

G->arc[1][2]=8;

G->arc[1][3]=9;

G->arc[1][4]=7;

G->arc[2][4]=5;

G->arc[3][4]=15;

G->arc[3][5]=6;

G->arc[4][5]=8;

G->arc[4][6]=9;

G->arc[5][6]=11;

for(i = 0; i < G->numVertexes; i++) {

for(j = i; j < G->numVertexes; j++) {

G->arc[j][i] =G->arc[i][j];

}

}

}

//快速排序的条件

int cmp(const void* a, const void* b) {

return (*(Edge*)a).weight - (*(Edge*)b).weight;

}

//找到根节点

int Find(int *parent, int f) {

while ( parent[f] > 0) {

f = parent[f];

}

return f;

}

// 生成最小生成树

void MiniSpanTree_Kruskal(MGraph G) {

int i, j, n, m;

int k = 0;

int parent[MAXVEX]; //用于寻找根节点的数组

Edge edges[MAXEDGE]; //定义边集数组,edge的结构为begin,end,weight,均为整型

// 用来构建边集数组并排序(将邻接矩阵的对角线右边的部分存入边集数组中)

for ( i = 0; i < G.numVertexes-1; i++) {

for (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++;

}

}

}

//为边集数组Edge排序

qsort(edges, G.numEdges, sizeof(Edge), cmp);

for (i = 0; i < G.numVertexes; i++)

parent[i] = 0;

printf("打印最小生成树：\n");

for (i = 0; i < G.numEdges; i++) {

n = Find(parent, edges[i].begin);//寻找边edge[i]的“首节点”所在树的树根

m = Find(parent, edges[i].end);//寻找边edge[i]的“尾节点”所在树的树根

//假如n与m不等，说明两个顶点不在一棵树内，因此这条边的加入不会使已经选择的边集产生回路

if (n != m) {

parent[n] = m;

printf("(%d, %d) %d\n", edges[i].begin, edges[i].end, edges[i].weight);

}

}

}

int main(void)

{

MGraph G;

CreateMGraph(&G);

MiniSpanTree_Kruskal(G);

return 0;

}

普里姆算法：

普里姆(Prim)算法，和克鲁斯卡尔算法一样，是用来求加权连通图的最小生成树的算法。

基本思想  对于图G而言，V是所有顶点的集合；现在，设置两个新的集合U和T，其中U用于存放G的最小生成树中的顶点，T存放G的最小生成树中的边。 从所有uЄU，vЄ(V-U) (V-U表示出去U的所有顶点)的边中选取权值最小的边(u, v)，将顶点v加入集合U中，将边(u, v)加入集合T中，如此不断重复，直到U=V为止，最小生成树构造完毕，这时集合T中包含了最小生成树中的所有边。

普里姆算法图解

以上图G4为例，来对普里姆进行演示(从第一个顶点A开始通过普里姆算法生成最小生成树)。

初始状态：V是所有顶点的集合，即V={A,B,C,D,E,F,G}；U和T都是空！  第1步：将顶点A加入到U中。      此时，U={A}。  第2步：将顶点B加入到U中。      上一步操作之后，U={A}, V-U={B,C,D,E,F,G}；因此，边(A,B)的权值最小。将顶点B添加到U中；此时，U={A,B}。  第3步：将顶点F加入到U中。      上一步操作之后，U={A,B}, V-U={C,D,E,F,G}；因此，边(B,F)的权值最小。将顶点F添加到U中；此时，U={A,B,F}。  第4步：将顶点E加入到U中。      上一步操作之后，U={A,B,F}, V-U={C,D,E,G}；因此，边(F,E)的权值最小。将顶点E添加到U中；此时，U={A,B,F,E}。  第5步：将顶点D加入到U中。      上一步操作之后，U={A,B,F,E}, V-U={C,D,G}；因此，边(E,D)的权值最小。将顶点D添加到U中；此时，U={A,B,F,E,D}。  第6步：将顶点C加入到U中。      上一步操作之后，U={A,B,F,E,D}, V-U={C,G}；因此，边(D,C)的权值最小。将顶点C添加到U中；此时，U={A,B,F,E,D,C}。  第7步：将顶点G加入到U中。      上一步操作之后，U={A,B,F,E,D,C}, V-U={G}；因此，边(F,G)的权值最小。将顶点G添加到U中；此时，U=V。

此时，最小生成树构造完成！它包括的顶点依次是：A B F E D C G。

普里姆算法的代码说明

以"邻接矩阵"为例对普里姆算法进行说明，对于"邻接表"实现的图在后面会给出相应的源码。

1. 基本定义

// 邻接矩阵

typedef struct _graph

{

char vexs[MAX]; // 顶点集合

int vexnum; // 顶点数

int edgnum; // 边数

int matrix[MAX][MAX]; // 邻接矩阵

}Graph, *PGraph;

// 边的结构体

typedef struct _EdgeData

{

char start; // 边的起点

char end; // 边的终点

int weight; // 边的权重

}EData;

Graph是邻接矩阵对应的结构体。  vexs用于保存顶点，vexnum是顶点数，edgnum是边数；matrix则是用于保存矩阵信息的二维数组。例如，matrix[i][j]=1，则表示"顶点i(即vexs[i])"和"顶点j(即vexs[j])"是邻接点；matrix[i][j]=0，则表示它们不是邻接点。  EData是邻接矩阵边对应的结构体。

2. 普里姆算法

#include

#include

#include

#include

#define MAX 100

#define INF (~(0x1<<31))

typedef struct Graph

{

char vexs[MAX];

int vexnum;

int edgnum;

int matrix[MAX][MAX];

} Graph,*PGraph;

typedef struct EdgeData

{

char start;

char end;

int weight;

} EData;

static int get_position(Graph g,char ch)

{

int i;

for(i=0; i

if(g.vexs[i]==ch)

return i;

return -1;

}

Graph* create_graph()

{

char vexs[]= {'A','B','C','D','E','F','G'};

int matrix[][7]=

{

{0,12,INF,INF,INF,16,14},

{12,0,10,INF,INF,7,INF},

{INF,10,0,3,5,6,INF},

{INF,INF,3,0,4,INF,INF},

{INF,INF,5,4,0,INF,8},

{16,7,6,INF,2,0,9},

{14,INF,INF,INF,8,9,0}

};

int vlen=sizeof(vexs)/sizeof(vexs[0]);

int i,j;

Graph *pG;

if((pG=(Graph*)malloc(sizeof(Graph)))==NULL)

return NULL;

memset(pG,0,sizeof(pG));

pG->vexnum=vlen;

for(i=0; ivexnum; i++)

pG->vexs[i]=vexs[i];

for(i=0; ivexnum; i++)

for(j=0; jvexnum; j++)

pG->matrix[i][j]=matrix[i][j];

for(i=0; ivexnum; i++)

{

for(j=0; jvexnum; j++)

{

if(i!=j&&pG->matrix[i][j]!=INF)

pG->edgnum++;

}

}

pG->edgnum/=2;

return pG;

}

void print_graph(Graph G)

{

int i,j;

printf("Matrix Graph: \n");

for(i=0; i

{

for(j=0; j

printf("%10d ",G.matrix[i][j]);

printf("\n");

}

}

EData* get_edges(Graph G)

{

EData *edges;

edges=(EData*)malloc(G.edgnum*sizeof(EData));

int i,j;

int index=0;

for(i=0; i

{

for(j=i+1; j

{

if(G.matrix[i][j]!=INF)

{

edges[index].start=G.vexs[i];

edges[index].end=G.vexs[j];

edges[index].weight=G.matrix[i][j];

index++;

}

}

}

return edges;

}

void prim(Graph G,int start)

{

int min,i,j,k,m,n,sum;

int index=0;

char prim[MAX];

int weight[MAX];

prim[index++]=G.vexs[start];

for(i=0; i

weight[i]=G.matrix[start][i];

weight[start]=0;

for(i=0; i

{

//i用来控制循环的次数，每次加入一个结点，但是因为start已经加入，所以当i为start是跳过

if(start==i)

continue;

j=0;

k=0;

min=INF;

for(k=0; k

{

if(weight[k]&&weight[k]

{

min=weight[k];

j=k;

}

}

sum+=min;

prim[index++]=G.vexs[j];

weight[j]=0;

for(k=0; k

{

if(weight[k]&&G.matrix[j][k]

weight[k]=G.matrix[j][k];

}

}

// 计算最小生成树的权值

sum = 0;

for (i = 1; i < index; i++)

{

min = INF;

// 获取prims[i]在G中的位置

n = get_position(G, prim[i]);

// 在vexs[0...i]中，找出到j的权值最小的顶点。

for (j = 0; j < i; j++)

{

m = get_position(G, prim[j]);

if (G.matrix[m][n]

min = G.matrix[m][n];

}

sum += min;

}

printf("PRIM(%c)=%d: ", G.vexs[start], sum);

for (i = 0; i < index; i++)

printf("%c ", prim[i]);

printf("\n");

}

int main()

{

Graph *pG;

pG=create_graph();

print_graph(*pG);

prim(*pG,0);

}

运行结果：