贪心法之最小生成树之Kruskal算法

A，实际应用：现实生活中经常需要计算某种方案的最小成本问题，比如希望利用最少量的电缆线连接一座建筑物中所有的计算机；再比如希望以最小的成本连接一个网络中的所有路由器等问题。把整个问题抽象成一个无向图，解决问题就是要构建一棵包含图中所有节点的树，并使构造出的树的总权值最小，即求解图的最小生成树问题。下面将介绍用于构造该种树的方法，Kruskal算法。

B，克鲁斯卡尔（Kruskal）算法：假设无向图中有n个节点，Kruskal算法总共选择n-1条边，所用的贪心法思想就是：每次从剩下的边中选择权重最小的边加入到树中，前提是新加入的边不能与已加入的边构成回路（不然就不能构成一棵树了），如果构成回路就抛弃这条边。

C，算法处理过程：

1）假设G是包含n个节点的连通网；

2）首先对图中的边按从小到大排序保存在数组E[]中；

3）然后循环遍历E中的每条边，每次判断改边是否会与已加入的边构成回路；

4）如果不构成回路就将边加入树中T[]中，否则抛弃，继续判断下一条边；

5）直到所有边都判断，加入或者抛弃一次之后，算法结束；

6）所得的树即为最小生成树。

值得注意的是我们如何判断当前判断的边是否会与已加入的边构成回路，一个解决方案就是判断边的两个端点是否都在已加入的边的端点集合当中。

下图为Kruskal算法构造最小生成树的过程：

D，算法实现：

#include "iostream"

using namespace std;

#define MAXVEX 50//图中最大节点数

typedef struct //定义边的数据结构

{

int start;//边的起点

int end;//边的终点

float weight;//边的权值

}VertexType;

typedef struct //定义邻接矩阵的数据结构

{

char vexs[MAXVEX];

VertexType edges[MAXVEX];

int vexNum, adgeNum;//分别表示图中节点个数和边的条数

}AGraph;

int main()

{

void createAGraph(AGraph *);

void kruskal(AGraph *, VertexType[]);

AGraph g;

VertexType v[MAXVEX];

createAGraph(&g);

kruskal(&g, v);

return 0;

}

//kruskal算法求解最小生成树

//g为无向网，v用于存储最小生成树的边

void kruskal(AGraph *g, VertexType v[])

{

void selectSort(VertexType[], int);

int collect[MAXVEX];

for(int i = 0; i < g->vexNum; ++i)

collect[i] = i;

selectSort(g->edges, g->adgeNum);

int min;//分别表示最小的生成树的总权值和当前树的节点数

min = 0;

cout<<"\n最小生成树由这些边构成：\n";

for(int j = 0; (j < g->adgeNum); ++j)//

{

int s = g->edges[j].start;

int e = g->edges[j].end;

//下面就是判断一条边的两个端点是否同在已加入边的端点集合中

while(s != collect[s])

s = collect[s];

while(e != collect[e])

e = collect[e];

if(s != e)//如果不在同一集合中，说明加入该条边不会构成回路

{

v[j] = g->edges[j];

min += g->edges[j].weight;

collect[e] = s;//将这两个端点加到同一个集合中去

cout<vexs[g->edges[j].start]<<"->"<vexs[g->edges[j].end]<<",";//输出边的信息

}

}

cout<<"\n最小生成树的总权重为："<

}

//用选择排序对n条边进行排序

void selectSort(VertexType edges[], int n)

{

int min;

VertexType temp;

for(int i = 0; i < n - 1; ++i)

{

min = i;

//循环找出剩余元素中最小的一个

for(int j = i + 1; j < n; ++j)

{

if(edges[min].weight > edges[j].weight)

{

min = j;

}

}

//将最小值与第一个元素交换位置

if(min != i)

{

temp = edges[i];

edges[i] = edges[min];

edges[min] = temp;

}

}

}

void createAGraph(AGraph *g)//创建图的无向网

{

int vNum, aNum;//分别代表要创建的图的节点数和边数

int start, end;//start->end表示节点start和end之间有一条边

int weight;//边的权重

cout<<"请输入图中节点的个数和边的条数:";

cin>>vNum>>aNum;

printf("\n请输入%d个节点的信息：", vNum);

//创建节点

for(int i = 0; i < vNum; ++i)

{

cin>>g->vexs[i];

}

cout<<"这里输出节点编号及其存储的节点信息"<

for(int k = 0; k < vNum; ++k)

cout<vexs[k]<<"";

cout<

//创建无向图的边信息

for(int j = 0; j < aNum; ++j)

{

cout<<"\n请输入第"<

cin>>start>>end>>weight;

g->edges[j].start = start;

g->edges[j].end = end;

g->edges[j].weight = weight;

}

//初始化vexNum和adgeNum

g->vexNum = vNum;

g->adgeNum = aNum;

}

运行结果：

E，复杂度分析

时间复杂度： Kruskal算法的时间复杂度由排序算法决定，若采用快排则时间复杂度为O(nlogn)。当然上述实现使用的是选择排序，所以时间复杂度为O（n^2）。