啥？移动公司要建立通信网（普里姆算法&克鲁斯卡尔算法）

最新推荐文章于 2024-04-01 11:40:29 发布

threecat.up

最新推荐文章于 2024-04-01 11:40:29 发布

阅读量780

点赞数 5

分类专栏： # 数据结构内功修炼（初遇）文章标签：普里姆算法克鲁斯卡尔算法最小生成树数据结构图论 C++

本文链接：https://blog.csdn.net/qq_43919400/article/details/103268974

版权

数据结构内功修炼（初遇）专栏收录该内容

25 篇文章 3 订阅

订阅专栏

前言：

假设要在n个城市之间建立通信网络网，则连通n个城市只需要n-1条路线，这时，自然会考虑到这样一个问题，如何在最节省经费的前提下建立这个通信网。

所以就要提到我们今天的主角，最小生成树的算法（Prim&Kruskal）。~~后面附上演示代码哦！！！~~

小知识：

首先我们要知道一个概念MST，用自己的话来说就是最小生成树里面一定包含了具有最小权值的边，这个很好理解。那么具体的性质是这样的：假设N=（V,E）是一个连通网，U是顶点集V的一个非空子集。若（u,v）是一条具有最小权值的边，其中u∈U，v∈V-U,则必定存在一棵包含边（u,v）的最小生成树。

普利姆算法和克鲁斯卡尔算法都是利用MST性质构造最小生成树的算法，只是普里姆算法比较适合稠密图，克鲁斯卡尔算法适合稀疏图。

一、普里姆算法（归并顶点）

1.构造过程

假设N=（V,E）是连通网，TE是N上最小生成树中边的集合。

①U={u。}（u。∈V），TE={}。

②在所有u∈U，v∈V-U的边（u,v）∈E中找一条权值最小的边（u。，v。）并入集合TE，同时v。并入u。

③重复②，直至U=V为止。

总结归纳：就是找到权值最小的，并入集合，然后当前集合与剩下的集合之间又找权值最小的，直至顶点都在集合里就找完了。看图也比较好理解：

算法描述：

void MiniSpanTree_Prim(AMGraph G,VerTextType u)

{//无向图G以邻接矩阵形式存储，从顶点u出发构造G的最小生成树T，输出T的各条边

    k = LocateVex(G,u);//k为顶点u的下标

    for(j=0;j<G.vexnum;++j)//对V-U的每一个顶点vj,初始化closedge[j]

        if(j!=k) closedge[j]={u,G.arcs[k][j]};//{adjvex,lowcost}

    closedeg[k].lowcost = 0;//初始，U={u}

    for(i=1;i<G.vexnum;++i)

    {//选择其余n-1个顶点，生成n-1条边（n=G.vexnum）

        k=Min(closedge);

        //求出T的下一个结点：第k个顶点，closedge[k]中存有当前最小边

        u0=closedge[k].adjcex;//u0为最小边的一个顶点，u0∈U
       
         v0=G.vexs[k];//v0为最小边的另一个顶点u0∈V-U

         cout<<u0<<v0;//输出当前最小的边（u0,v0）

        closedge[k].lowcost=0;//第k个顶点并入U集

        for(j=0;j<G.vexnum;++j)

            if(G.arcs[k][j]<closedge[j].lowcost)//新顶点并入U后重新选择最小边

        closedge[j]={G.vexs[k],G.arcs[k][j]};

    }
}

二、克鲁斯卡尔算法

算法步骤：

将数组Edge中的元素按权值从最小到大排序
依次查看数组Edge中的边，循环执行以下操作

（1）依次从排好序的数组Edge中选出一条边（U1,U2）；

（2）在Vexset中分别查找v1和v2所在的连通分量vs1和vs2，进行判断：

如果vs1和vs2不等，表明所选的两个顶点分属不同的连通分量，输出此边，并合并vs1和vs2两个连通分量；
如果vs1和vs2相等，表明所选的两个顶点属于同一个连通分量，舍去此边而选择下一条权值最小的边。

归纳：就是最小边排序之后按照这个顺序来进行加边，当这条边加入时不构成连通分量（简单来说就是环路），那么加进来，继续操作。如构成连通分量，舍弃这条边，继续读下一条最小的。

如图：

后记：

普里姆算法和克克鲁斯卡尔算法的应用是很广泛的，把它们学好会很有用。

演示代码：

普里姆算法：

//普里姆算法
#include <iostream>
using namespace std;

typedef char VerTexType;
typedef int ArcType;
#define MVNum 100
#define MaxInt 32767                    	//表示极大值，即∞

//辅助数组的定义，用来记录从顶点集U到V-U的权值最小的边
struct{
	VerTexType adjvex;						//最小边在U中的那个顶点
	ArcType lowcost;						//最小边上的权值
}closedge[MVNum];

//- - - - -图的邻接表存储表示- - - - - 						
typedef char VerTexType;              		//假设顶点的数据类型为字符型 
typedef int ArcType;                  		//假设边的权值类型为整型 
typedef struct{ 
	VerTexType vexs[MVNum];            		//顶点表 
	ArcType arcs[MVNum][MVNum];      		//邻接矩阵 
	int vexnum,arcnum;                		//图的当前点数和边数 
}AMGraph;

int LocateVex(AMGraph G , VerTexType v){
	//确定点v在G中的位置
	for(int i = 0; i < G.vexnum; ++i)
		if(G.vexs[i] == v)
			return i;
		return -1;
}//LocateVex

void CreateUDN(AMGraph &G){ 
    //采用邻接矩阵表示法，创建无向网G 
	int i , j , k;
	cout <<"请输入总顶点数，总边数，以空格隔开:";
    cin >> G.vexnum >> G.arcnum;							//输入总顶点数，总边数
	cout << endl;

	cout << "输入点的名称，如a" << endl;

    for(i = 0; i < G.vexnum; ++i){   
		cout << "请输入第" << (i+1) << "个点的名称:";
		cin >> G.vexs[i];                        			//依次输入点的信息 
	}
	cout << endl;
    for(i = 0; i < G.vexnum; ++i)                			//初始化邻接矩阵，边的权值均置为极大值MaxInt 
		for(j = 0; j < G.vexnum; ++j)   
			G.arcs[i][j] = MaxInt;
	cout << "输入边依附的顶点及权值，如a b 5" << endl;
	for(k = 0; k < G.arcnum;++k){							//构造邻接矩阵 
		VerTexType v1 , v2;
		ArcType w;
		cout << "请输入第" << (k + 1) << "条边依附的顶点及权值:";
		cin >> v1 >> v2 >> w;								//输入一条边依附的顶点及权值
		i = LocateVex(G, v1);  j = LocateVex(G, v2);		//确定v1和v2在G中的位置，即顶点数组的下标 
		G.arcs[i][j] = w;									//边<v1, v2>的权值置为w 
		G.arcs[j][i] = G.arcs[i][j];						//置<v1, v2>的对称边<v2, v1>的权值为w 
	}//for
}//CreateUDN 

int Min(AMGraph G){
	//返回权值最小的点
	int i;
	int index = -1;
	int min = MaxInt;
	for(i = 0 ; i < G.vexnum ; ++i){
		if(min > closedge[i].lowcost && closedge[i].lowcost != 0){
			min = closedge[i].lowcost;
			index = i;
		}
	}//for
	return index;
}//Min

void MiniSpanTree_Prim(AMGraph G, VerTexType u){ 
    //无向网G以邻接矩阵形式存储，从顶点u出发构造G的最小生成树T，输出T的各条边  
	int k , j , i;
	VerTexType u0 , v0;
    k =LocateVex(G, u);           										//k为顶点u的下标 
    for(j = 0; j < G.vexnum; ++j){     									//对V-U的每一个顶点vi，初始化closedge[i] 
		if(j != k){  
			closedge[j].adjvex = u;
			closedge[j].lowcost = G.arcs[k][j];							//{adjvex, lowcost}
		}//if
	}//for
	closedge[k].lowcost = 0;        									//初始，U = {u}
	for(i = 1; i < G.vexnum; ++i){     									//选择其余n-1个顶点，生成n-1条边(n= G.vexnum) 
		k = Min(G);  
		//求出T的下一个结点：第k个顶点，closedge[k]中存有当前最小边 
		u0 = closedge[k].adjvex;     									//u0为最小边的一个顶点，u0∈U 
		v0 = G.vexs[k];            										//v0为最小边的另一个顶点，v0∈V-U 
		cout << "边  " <<u0 << "--->" << v0 << endl;           			//输出当前的最小边(u0, v0) 
		closedge[k].lowcost = 0;   		//第k个顶点并入U集 
		for(j = 0; j < G.vexnum; ++j) 
			if(G.arcs[k][j] < closedge[j].lowcost){						//新顶点并入U后重新选择最小边 
				closedge[j].adjvex = G.vexs[k];
				closedge[j].lowcost = G.arcs[k][j];
			}//if 
	}//for 
}//MiniSpanTree_Prim 

int main(){
	cout << "************普里姆算法**************" << endl << endl;
	AMGraph G;
	CreateUDN(G);
	cout << endl;
	cout << "无向图G创建完成！" << endl;
	cout <<endl;

	cout << "******利用普里姆算法构造最小生成树结果：******" << endl;
	MiniSpanTree_Prim(G , 'a');
	cout <<endl;
	return 0;
}//main

例子就是上图例子的图，Exmple

克鲁斯卡尔算法：

//算法:克鲁斯卡尔算法

#include <iostream>
using namespace std;

typedef char VerTexType;              		//假设顶点的数据类型为字符型
typedef int ArcType;
#define MVNum 100                       	//最大顶点数
#define MaxInt 32767                    	//表示极大值，即∞

//----------------图的邻接矩阵---------------------
typedef struct{
	VerTexType vexs[MVNum];            		//顶点表
	ArcType arcs[MVNum][MVNum];      		//邻接矩阵
	int vexnum,arcnum;                		//图的当前点数和边数
}AMGraph;

//辅助数组Edges的定义
struct{
	VerTexType Head;						//边的始点
	VerTexType Tail;						//边的终点
	ArcType lowcost;						//边上的权值
}Edge[(MVNum * (MVNum - 1)) / 2];

int Vexset[MVNum];							//辅助数组Vexset的定义

int LocateVex(AMGraph G , VerTexType v){
	//确定点v在G中的位置
	for(int i = 0; i < G.vexnum; ++i)
		if(G.vexs[i] == v)
			return i;
		return -1;
}//LocateVex

void CreateUDN(AMGraph &G){
    //采用邻接矩阵表示法，创建无向网G
	int i , j , k;
	cout <<"请输入总顶点数，总边数，以空格隔开:";
    cin >> G.vexnum >> G.arcnum;						//输入总顶点数，总边数
	cout << endl;

	cout << "输入点的名称，如a" << endl;

    for(i = 0; i < G.vexnum; ++i){
		cout << "请输入第" << (i+1) << "个点的名称:";
		cin >> G.vexs[i];                        		//依次输入点的信息
	}
	cout << endl;
	for(i = 0; i < G.vexnum; ++i)                		//初始化邻接矩阵，边的权值均置为极大值MaxInt
		for(j = 0; j < G.vexnum; ++j)
			G.arcs[i][j] = MaxInt;
	cout << "输入边依附的顶点及权值，如a b 6" << endl;
	for(k = 0; k < G.arcnum;++k){						//构造邻接矩阵
		VerTexType v1 , v2;
		ArcType w;
		cout << "请输入第" << (k + 1) << "条边依附的顶点及权值:";
		cin >> v1 >> v2 >> w;                           //输入一条边依附的顶点及权值
		i = LocateVex(G, v1);  j = LocateVex(G, v2);	//确定v1和v2在G中的位置，即顶点数组的下标
		G.arcs[i][j] = w;								//边<v1, v2>的权值置为w
		G.arcs[j][i] = G.arcs[i][j];					//置<v1, v2>的对称边<v2, v1>的权值为w
		Edge[k].lowcost = w;
		Edge[k].Head = v1;
		Edge[k].Tail = v2;
	}//for
}//CreateUDN

//----------冒泡排序-------------------
void Sort(AMGraph G){
	int m = G.arcnum - 2;
	int flag = 1;
	while((m > 0) && flag == 1){
		flag = 0;
		for(int j = 0 ; j <= m ; j++){
			if(Edge[j].lowcost > Edge[j+ 1].lowcost){
				flag = 1;

				VerTexType temp_Head = Edge[j].Head;
				Edge[j].Head = Edge[j+ 1].Head;
				Edge[j + 1].Head = temp_Head;


				VerTexType temp_Tail = Edge[j].Tail;
				Edge[j].Tail = Edge[j+ 1].Tail;
				Edge[j + 1].Tail = temp_Tail;

				ArcType temp_lowcost = Edge[j].lowcost;
				Edge[j].lowcost = Edge[j+ 1].lowcost;
				Edge[j + 1].lowcost = temp_lowcost;
			}//if
		}//for
		--m;
	}//while
}//Sort

void MiniSpanTree_Kruskal(AMGraph G){
    //无向网G以邻接矩阵形式存储，构造G的最小生成树T，输出T的各条边
    int i , j , v1 , v2 , vs1 , vs2;
	Sort(G);                 							//将数组Edge中的元素按权值从小到大排序
	for(i = 0; i < G.vexnum; ++i)     					//辅助数组，表示各顶点自成一个连通分量
        Vexset[i] = i;
    for(i = 0; i < G.arcnum; ++i){
		//依次查看排好序的数组Edge中的边是否在同一连通分量上
		v1 =LocateVex(G, Edge[i].Head);     			//v1为边的始点Head的下标
		v2 =LocateVex(G, Edge[i].Tail);     			//v2为边的终点Tail的下标
		vs1 = Vexset[v1];       						//获取边Edge[i]的始点所在的连通分量vs1
		vs2 = Vexset[v2];       						//获取边Edge[i]的终点所在的连通分量vs2
		if(vs1 != vs2){         						//边的两个顶点分属不同的连通分量
			cout << Edge[i].Head << "-->" << Edge[i].Tail << endl;		//输出此边
			for(j = 0; j < G.vexnum; ++j)      			//合并vs1和vs2两个分量，即两个集合统一编号
				if(Vexset[j] == vs2) Vexset[j] = vs1;	//集合编号为vs2的都改为vs1
		}//if
    }//for
}//MiniSpanTree_Kruskal

int main(){
	cout << "************鲁斯卡尔算法**************" << endl << endl;
	AMGraph G;
	CreateUDN(G);

	cout <<endl;
	cout << "*****无向网G创建完成！*****" << endl;

	cout <<endl;
	MiniSpanTree_Kruskal(G);
	return 0;
}///main

完毕，冲鸭！！！

threecat.up

关注

5
点赞
踩
8

收藏

觉得还不错? 一键收藏
打赏
0
评论
啥？移动公司要建立通信网（普里姆算法&克鲁斯卡尔算法）

前言：假设要在n个城市之间建立通信网络网，则连通n个城市只需要n-1条路线，这时，自然会考虑到这样一个问题，如何在最节省经费的前提下建立这个通信网。所以就要提到我们今天的主角，最小生成树的算法（Prim&Kruskal）。后面附上演示代码哦！！！小知识：首先我们要知道一个概念MST，用自己的话来说就是最小生成树里面一定包含了具有最小权值的边，这个很好理解。那么具...
复制链接

扫一扫