数据结构-图-最小生成树-克鲁斯卡尔算法（Kruskal）边多的用prim，边少的用kruskal

最新推荐文章于 2022-07-06 19:28:16 发布

weixin_39518639

最新推荐文章于 2022-07-06 19:28:16 发布

阅读量177

点赞数

分类专栏：数据结构文章标签：算法数据结构链表 c++

本文链接：https://blog.csdn.net/weixin_39518639/article/details/107179855

版权

数据结构专栏收录该内容

26 篇文章 0 订阅

订阅专栏

在这里插入图片描述

思路：设置一个数组p[edgenum],存放访问过的边，设置一个边集数组结构，存放边的begin,end,weight.
把所有边放入边集数组，并按权重从小到大排序。n为p的下标 m为p的值
1：权重 7 输出 h e（7 4）数组p(000070000) n=4 m=7
2：权重8 输出 i c (8 2) p(008070000) n=2 m=8
3：权重10输出 ba (1 0) p(108070000) n=0 m=1
4：权重11输出 fa （5 0） p(158070000) n=0 由于n 为0的时候 p[0]有值为1，所以取值当下标p[1]=0没值，所以n=1 m=5
5：权重12输出ib (8 1) p(158078000) n=1 p[1]=5 p[5]=0 所以n=5 m=8
6：权重16输出hd(7 3) p(158778000) n=3 m=7
7：权重16输出ga(6 1) p(158778006)n=1 p[1]=5 p[5]=8 p[8]=0 所以n=8 m=6
8：权重17g f(6 5)不输出，因为形成环，n=5 p[5]=8 p[8]=6 p[6]=0 所以n=6 m=6 m=n说明在用一个集合里面。集合从p[0]开始 p[0]=1 p[1]=5 p[5]=8 p[8]=6 所以 n=6 m=6说明在一个集合里形成环路。
9：权重18 cb (2 1)不输出，因为形成环 n=1 p[1]=5 p[5]=8 p[8]=6 所以n=6 m=2 p[2]=8 p[8]=6 所以m=6,说明在用一个集合里面。集合从p[0]开始 p[0]=1 p[1]=5 p[5]=8 p[8]=6 所以 n=6 m=6说明在一个集合里形成环路。
10：权重19输出 hg（7 6） p(158778006) n=6 m=7
~
~其余边都与连接过的边会形成环
~
权重20 ed（4 3）的边 n=3 p[3]=7 p[7]=0 所以n=7 m=4 p[4]=7 p[7]=0,所以m=7 m=n,此时形成环路的是另外一个集合集合 p[4],p[7] p[3]
也就是p数组存在两个集合 p[0] p[1] p[2] p[5] p[6] p[8] 和集合 p[4],p[7] p[3]

克鲁斯卡尔算法（Kruskal）算法关键之处在于判断是否要加入树的边会跟已经加入的边形成回环。上述方法巧妙实现了判断。

structfun.h

//数据结构函数头文件

#include <stdio.h>
#include <iostream>
#include<string>

using std::cout;
using std::cin;
using std::string;

#define MAXSIZE 100
#define OK 1
#define ERROR 0
#define INFINITY 65535//无穷大
typedef string ElemType;
typedef string VertexType;//图顶点数据类型
typedef int EdgeType;//图边的数据类型

//定义一个数组队列
typedef struct Queue
{
int date[MAXSIZE];
int num;
};

//数据结构-图-----------------------------------------------------------------------------

//1、邻接矩阵（Adjacency Martix）
	//设置一个顶点数组vertex[],设置一个边数组arc[][]
typedef struct
{
	//图顶点数组
	VertexType vertex[MAXSIZE];
	//图边数组
	EdgeType arc[MAXSIZE][MAXSIZE];	//边的值就是权重
	int vertexnum,arcnum;
}AdjMarGraph;


//5、图的边集数组
typedef struct
{
	int begin;//开始定点下标
	int end;//结束顶点下标
	int w;//权重
}EdgeArray[MAXSIZE];

//1、邻接矩阵
	//无向图的邻接矩阵
int CreateAdjMaxGraph(AdjMarGraph *amg);
int AdjMarDepthFirstSearch(AdjMarGraph *amg,int f);//邻接矩阵深度遍历 int f为开始的结点
int AdjMarBreadthFirstSearch(AdjMarGraph *amg);
int AMBFS(AdjMarGraph *amg);
//图-最小生成路径（采用邻接矩阵）
int AdjMarGraphLeastPath(AdjMarGraph *amg);//prim算法
int AdjMarGraphLeastPathKruskal(AdjMarGraph *amg);//Kruskal算法

structfun.cpp

#include<iostream>
#include<stdio.h>
#include<string>
#include<sstream>
#include"structfun.h"


using std::cout;
using std::cin;
using std::string;
using std::endl;
using std::ostringstream;


//图结构函数-----------------------------------------------
//1、邻接矩阵
	//图的邻接矩阵
int CreateAdjMaxGraph(AdjMarGraph *amg)
{
	int i=0;
	amg->vertexnum=0;
	amg->arcnum=0;

	while(1)//输入顶点;
	{
		printf("请输入顶点，结束用#号：");
	/*	scanf("%s",&amg->vertex[i]);*///string不能采用scanf,采用scanf必须先给字符串
		//预先分配空间，然后采用amg->vertex[i][0]scanf采用的是字符数组的形式存储字符串。
		//amg->vertex[i].resize(100);
		//scanf("%s",&amg->vertex[i][0]);
		cin>>amg->vertex[i];

		if(amg->vertex[i]=="#")
			break;
		amg->vertexnum++;
		i++;
		
	}
	for(i=0;i<amg->vertexnum;i++)//初始化边值为0
		for(int j=0;j<amg->vertexnum;j++)
		{
			if(i==j)
				amg->arc[i][j]=0;
			else
			amg->arc[i][j]=INFINITY;
		}
	//创建邻接矩阵图的边
	while(1)
	{
		int v1,v2,value;
		printf("请输入图的边的顶点下标（v1,v2,value）结束输入（0,0,0）：");
		scanf("%d,%d,%d",&v1,&v2,&value);
		amg->arc[v1][v2]=value;
		amg->arc[v2][v1]=value;//无向图增加对等矩阵另外一边的值
		if(!v1&!v2&!value)
			break;
		amg->arcnum++;	
	}
	
	//输出图的邻接矩阵
	printf("图的邻接矩阵:\n");
	for(i=0;i<amg->vertexnum;i++)
	{
		printf("%s: ",amg->vertex[i].c_str());
		for(int j=0;j<amg->vertexnum;j++)
			{
				printf("%d  ",amg->arc[i][j]);
				if(j==amg->vertexnum-1)
					printf("\n");
			}
	}
return OK;
}


//图-最小生成路径（采用邻接矩阵）
int AdjMarGraphLeastPath(AdjMarGraph *amg)
{
	int weight[MAXSIZE];//定义一个数组存储权重
	int vertexSubscript[MAXSIZE];//对边顶点下标数组
	int i=0,n=0;
	//初始化访问标识,及权重数组
	//for(i;i<amg->vertexnum;i++)
	//		visited[i]=false;
	for(i=0;i<amg->arcnum;i++)
	{
		weight[i]=INFINITY;
		vertexSubscript[i]=0;

	}	
	//开始遍历
	 //vertexSubscript[0]=0;
	weight[0]=0;
	 for(i=0;i<amg->vertexnum-1;i++)
	{
		for(int j=0;j<amg->vertexnum;j++)
		{
			if(amg->arc[n][j]!=INFINITY&&i!=j&&weight[j]>amg->arc[n][j])//满足条件的插入到边集数组，不能少了&&weight[j]>amg->arc[i][j]这个判断，要矩阵中的元素权重要小于weight里面的才进行擦如，始终保持weight里面的权重是最小的。
			{
				weight[j]=amg->arc[n][j];//权重插入数组
				vertexSubscript[j]=n;//插入顶点下
			}
		}
		//查找边集数组中的最小值，并输出，同时删除输出的边，两端节点设置成已访问。
		int k=0,min=INFINITY,temp=0;//temp存储下标
		
		while(k<amg->vertexnum)//查找最小值的坐标
		{
			if(weight[k]<min&&weight[k]!=0)
			{
				min=weight[k];
				temp=k;
			}
			k++;
		}
		//不能用if(!visited[temp])
		if(vertexSubscript[temp]!=INFINITY)
		{
			//amg->vertex[i].c_str()不能用i因为前面的节点可能不是当前循环的索引
			printf("%s,(%d,%d权重:%d)",amg->vertex[n].c_str(),vertexSubscript[temp],temp,weight[temp]);
			/*visited[vertexSubscript[temp]]=true;*///设置定点为访问过的


			//for(temp;temp<amg->arcnum;temp++)
			//	weight[temp]=weight[temp+1];//删除已经访问过边的权重；
			weight[temp]=0;//不能删，因为位置是对应顶点下标的；
			vertexSubscript[temp]=0;
			n=temp;
		}
	}

	return OK;
}//prim算法。


int find(int *p,int f)
{
	while(p[f]>0)
		f=p[f];
	return f;
}
int AdjMarGraphLeastPathKruskal(AdjMarGraph *amg)//Kruskal算法
{
	EdgeArray edgearray;
	int i,j,intedge=0;
	int p[MAXSIZE];//定义一个数组存储访问过的边的begin

	//1、把边添加到边集数组；
	for(i=0;i<amg->vertexnum;i++)
		for(j=0;j<i;j++)//双向图只要记录一条边就可以
			if(amg->arc[i][j]!=INFINITY)
			{
				edgearray[intedge].begin=j;
				edgearray[intedge].end=i;
				edgearray[intedge].w=amg->arc[i][j];
				intedge++;
			}

	//2、边集数组排序
		for(i=0;i<amg->arcnum;i++)
			for(j=i+1;j<amg->arcnum;j++)
			{
				if(edgearray[i].w>edgearray[j].w)//比较大小，条件成立交换
				{
					edgearray[i].begin=edgearray[i].begin^edgearray[j].begin;
					edgearray[i].end=edgearray[i].end^edgearray[j].end;
					edgearray[i].w=edgearray[i].w^edgearray[j].w;

					edgearray[j].begin=edgearray[i].begin^edgearray[j].begin;
					edgearray[j].end=edgearray[i].end^edgearray[j].end;
					edgearray[j].w=edgearray[i].w^edgearray[j].w;

					edgearray[i].begin=edgearray[i].begin^edgearray[j].begin;
					edgearray[i].end=edgearray[i].end^edgearray[j].end;
					edgearray[i].w=edgearray[i].w^edgearray[j].w;	
				}
			}

			for(i=0;i<amg->arcnum;i++)
				p[i]=0;
			for(i=0;i<amg->arcnum;i++)
			{
				int m,n;
				m=find(p,edgearray[i].end);
				n=find(p,edgearray[i].begin);
				if(m!=n)
				{
					printf("(%d,%d)",edgearray[i].begin,edgearray[i].end);
					p[n]=m;
				}
			}

return OK;

}

main.cpp


#include<iostream>
#include<stdio.h>
#include <stdlib.h>
#include<string>
#include"structfun.h"

using std::string;
using std::printf;
using std::scanf;
using std::endl;
using std::to_string;

void main()
{
//图的邻接矩阵
AdjMarGraph amg;
CreateAdjMaxGraph(&amg);//创建图的邻接矩阵
//AdjMarDepthFirstSearch(&amg,0);//图的邻接矩阵深度优先遍历
// AdjMarBreadthFirstSearch(&amg);//广度优先遍历（递归）
 //AMBFS(&amg);//（非递归）
//AdjMarGraphLeastPath(&amg);//图-最小生成路径（采用邻接矩阵）
AdjMarGraphLeastPathKruskal(&amg);

//图的邻接表
//AdjListGraph alg;
//CreateAdjListGraph(&alg);
AdjListDepthFirstSearch(&alg,0);
//AdjListBreadthFirstSearch(&alg);

//图的十字链表
//OrthogonalListGraph olg;
//CreateOrthogonalListGraph(&olg);

//图的邻接多重表
//AdjacencyMultipleTableGraph amtg;
//CreateAdjacencyMultipleTableGraph(&amtg);

system("pause");
}

weixin_39518639

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
数据结构-图-最小生成树-克鲁斯卡尔算法（Kruskal）边多的用prim，边少的用kruskal

思路：设置一个数组p[edgenum],存放访问过的边，设置一个边集数组结构，存放边的begin,end,weight.把所有边放入边集数组，并按权重从小到大排序。n为p的下标 m为p的值1：权重 7 输出 h e（7 4）数组p(000070000) n=4 m=72：权重8 输出 i c (8 2) p(008070000) n=2 m=83：权重10输出 ba (1 0) p(108070000) n=0 m=14：权重11输出 fa ..
复制链接

扫一扫