再写——Prim && Kruskal

最新推荐文章于 2021-05-16 15:45:42 发布
最新推荐文章于 2021-05-16 15:45:42 发布
阅读量1.9k 收藏 1
点赞数 2
分类专栏： Data Structure 文章标签： tree 算法 graph string c struct
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jkay_wong/article/details/6975151
版权

重新写了最小生成树的两个经典算法—— prim 和 kruskal算法，之前写的Prim算法，是比较直接的 就是先让边的集合为空，然后在扫描最小边的过程中，也是根据该算法的定义来写的 是比较直接的写法 看这里 就是之前的Prim算法实现 ，这次实现的，个人比较喜欢。

思想是这样的：

（1）先在最小树的顶点集U={v},以和v相邻的所有边为候选边；

（2）重复以下步骤n-1次，使得其他n-1个顶点加入到U中：

1、从候选边中选出一条权值最小的，设该边在V-U中的顶点是vk,将vk加入U中，删除和vk相邻的边(程序中以一个标志来表示)

2、考察当前V-U中所有顶点vj，修改候选边：若(vk,vj)的权值小于原来和vj关联的候选变，就用后者作为候选边。

下面是代码：

//prim.h

#include <iostream>
#include <string>
#include <queue>
using namespace std;

const int MAX_VEX_NUM=20;
const int MAX_NUM=32767;
bool visited[20]; 

struct Tree_Edge
{
	int star;
	int end;
	int weight;
};

class MGraph
{
private:
	string vexs[MAX_VEX_NUM];
	int arcs[MAX_VEX_NUM][MAX_VEX_NUM];
	int vexnum;
	int arcnum;
public:
	int Get_VexNum()
	{
		return vexnum;
	}

	int Locate_Vex(string v)
	{
		for(int i=0;i<vexnum;i++)
			if(vexs[i] == v)
				return i;
		return -1;
	}

	void Create_MG()
	{
		//构造无向图的邻接矩阵
		int i,j,k;
		cout<<"输入图的顶点数目(少于20): ";
		cin>>vexnum;

		while(vexnum>20)
		{
			cout<<"输入的顶点数超过20，请重新输入：";
			cin>>vexnum;
		}

		cout<<"输入各个顶点名称：";
		for(i=0;i<vexnum;i++)
			cin>>vexs[i];

		for(i=0;i<vexnum;i++)
			for(j=0;j<vexnum;j++)
			{
				arcs[i][j]=MAX_NUM;
			}
		
		cout<<"输入边的总数：";
		cin>>arcnum;

		string v1,v2;
		int w;
		for(k=0;k<arcnum;k++)
		{
			cout<<"输入每条边对应的两个顶点和该边对应的权值：";
			cin>>v1>>v2>>w;
			i=Locate_Vex(v1);
			j=Locate_Vex(v2);

			while(i == -1 || j == -1)
			{
				cout<<"输入的顶点中有不符合要求的，重新输入：";
				cin>>v1>>v2;
				i=Locate_Vex(v1);
				j=Locate_Vex(v2);
			}

			arcs[i][j]=w;
			arcs[j][i]=w;
		}
	
		cout<<"无向网构造完成"<<endl;
	}

	void DFS_Traverse()
	{
		for(int i=0;i<vexnum;i++)
			visited[i]=false;
		for(i=0;i<vexnum;i++)
			if(!visited[i])
				DFS(i);
	}

	void DFS(int v)
	{
		visited[v]=true;
		cout<<vexs[v]<<"  ";
		
		for(int j=0;j<vexnum;j++)
			if(arcs[v][j] != MAX_NUM && !visited[j])
				DFS(j);
	}

	void BFS_Traverse()
	{
		queue<int> q;
		int u,w,v;
		for(v=0;v<vexnum;v++)
			visited[v]=false;

		for(v=0;v<vexnum;v++)
		{
			if(!visited[v])
			{
				visited[v]=true;
				cout<<vexs[v]<<"  ";
				q.push(v);

				while(!q.empty())
				{
					u=q.front();
					q.pop();

					for(w=0;w<vexnum;w++)
					{
						if( (arcs[u][w] != MAX_NUM) && !visited[w])
						{
							visited[w]=true;
							cout<<vexs[w]<<"  ";
							q.push(w);
						}
					}
				}
			}
		}
	}

	void Prim_Min_Tree(int v,Tree_Edge c[])
	{
		int lowcast[MAX_NUM];
		int closet[MAX_NUM];
		int i,min,j,k;
	
		for(i=0;i<vexnum;i++)
		{
			lowcast[i]=arcs[v][i];
			closet[i]=v;
		}
	
		lowcast[v]=0;
		
		for(i=1;i<vexnum;i++)
		{
			min=MAX_NUM;
			for(j=0;j<vexnum;j++)
			{
				if(lowcast[j]!=0 && lowcast[j]<min)
				{
					min=lowcast[j];
					k=j;
				}
			}
			lowcast[k]=0; //标志该顶点已经是U中顶点
			
			c[i].star=closet[k];
			c[i].end=k;
			c[i].weight=min;

			//下面是修改lowcast和closet
			for(j=0;j<vexnum;j++)
			{
				if(arcs[k][j]<lowcast[j])
				{
					lowcast[j]=arcs[k][j];
					closet[j]=k;
				}
			}
		}

		cout<<"最小生成树 完成~~"<<endl;
	}

	void Print_Tree(Tree_Edge c[])
	{
		for(int i=1;i<vexnum;i++)
			cout<<vexs[c[i].star]<<"-->"<<vexs[c[i].end]<<" : "<<c[i].weight<<endl;
	}
};

#include "prim.h"
#include <iostream>
using namespace std;

int main()
{
	MGraph G;
	G.Create_MG();
	
	cout<<"图的深度优先遍历为：";
	G.DFS_Traverse();
	cout<<endl;
	
	cout<<"图的广度优先遍历为：";
	G.BFS_Traverse();
	cout<<endl;
	
	string v;
	int pos;
	cout<<"输入建立最小树的起点的名称：";
	cin>>v;
	pos=G.Locate_Vex(v);
	while(pos == -1)
	{
		cout<<"顶点不存在，重新输入：";
		cin>>v;
		pos=G.Locate_Vex(v);
	}
	
	Tree_Edge c[MAX_NUM];
	G.Prim_Min_Tree(pos,c);

	cout<<"最小树的边的组成如下所示："<<endl;
	G.Print_Tree(c);

	return 0;
}

测试结果： 

输入图的顶点数目(少于20): 6
输入各个顶点名称：v1 v2 v3 v4 v5 v6
输入边的总数：10
输入每条边对应的两个顶点和该边对应的权值：v1 v2 6
输入每条边对应的两个顶点和该边对应的权值：v1 v3 1
输入每条边对应的两个顶点和该边对应的权值：v1 v4 5
输入每条边对应的两个顶点和该边对应的权值：v2 v5 3
输入每条边对应的两个顶点和该边对应的权值：v2 v3 5
输入每条边对应的两个顶点和该边对应的权值：v3 v4 5
输入每条边对应的两个顶点和该边对应的权值：v3 v6 4
输入每条边对应的两个顶点和该边对应的权值：v4 v6 2
输入每条边对应的两个顶点和该边对应的权值：v3 v5 6
输入每条边对应的两个顶点和该边对应的权值：v5 v6 6
无向网构造完成
图的深度优先遍历为：v1  v2  v3  v4  v6  v5
图的广度优先遍历为：v1  v2  v3  v4  v5  v6
输入建立最小树的起点的名称：v1
最小生成树 完成~~
最小树的边的组成如下所示：
v1-->v3 : 1
v3-->v6 : 4
v6-->v4 : 2
v3-->v2 : 5
v2-->v5 : 3
Press any key to continue


kruskal算法的一个中心思想就是在构造最小树的过程中，不可以使新边和原来的边构成回路，这次写的和之前写的有点不一样的就是，排序时，用了快排，在判断新边是否会和现在的边构成回路时，用了并查集。这个算法也是并查集的一个经典的运用，之前写的那个，用了并查集思想，但是这次是写了一个并查集然后用的，比较明显，看起来也比较清晰。之前写的kruskul算法实现

下面是代码：

//并查集头文件
#ifndef UFSET_H_
#define UFSET_H_

#include <iostream>
using namespace std;

const int MAX_SIZE=100;

int parent[MAX_SIZE];
int rank[MAX_SIZE];

int Find(int x)
{
	int y,root,w;
	y=x;
	while(parent[y]!=y)
	{
		y=parent[y];
	}
	root=y;
	y=x;
	while(parent[y]!=y) //执行路径压缩
	{
		w=parent[y];
		parent[y]=root;
		y=w;
	}
	return root;
}

void Union(int root1,int root2)
{
	int u,v;
	u=Find(root1);
	v=Find(root2);
	if(rank[u]<=rank[v])
	{
		parent[u]=v;
		if(rank[u]==rank[v])
			++rank[v];
	}
	else
		parent[v]=u;
}

void Init()
{
	memset(rank,0,sizeof(rank));
	for(int i=1;i<MAX_SIZE;i++)
		parent[i]=i;
}

#endif

//图的定义以及实现的头文件
#ifndef GRAPH_H_
#define GRAPH_H_

#include "ufset.h"
#include <iostream>
#include <string>
#include <queue>
using namespace std;

const int MAX_VEX_NUM=20;
const int MAX_NUM=32767;
bool visited[MAX_VEX_NUM];

struct Tree_Edge
{
	int star;
	int end;
	int weight;
}c[MAX_NUM];

void Quick_Sort(int low,int high);

class MGraph
{
private:
	string vexs[MAX_VEX_NUM];
	int arcs[MAX_VEX_NUM][MAX_VEX_NUM];
	int arcnum;
	int vexnum;
public:
	int Locate_Vex(string v)
	{
		for(int i=0;i<vexnum;i++)
			if(vexs[i] == v)
				return i;
		return -1;
	}

	void Create_Graph()
	{
		int i,j,v1,v2,w;
		string u,v;
		cout<<"输入定点数目(少于20):  ";
		cin>>vexnum;

		while(vexnum>20)
		{
			cout<<"请输入小于20的整数：";
			cin>>vexnum;
		}
		
		cout<<"输入顶点名称：";
		for(i=0;i<vexnum;i++)
			cin>>vexs[i];

		//初始化邻接矩阵
		for(i=0;i<vexnum;i++)
			for(j=0;j<vexnum;j++)
				arcs[i][j]=MAX_NUM;

		cout<<"输入边的总数：";
		cin>>arcnum;

		for(i=0;i<arcnum;i++)
		{
			cout<<"输入每一条边对应的两个顶点和该边权值：";
			cin>>u>>v>>w;

			v1=Locate_Vex(u);
			v2=Locate_Vex(v);
			while(v1 == -1 || v2 == -1)
			{
				cout<<"顶点中有不符合要求的，请重新输入：";
				cin>>u>>v;
				v1=Locate_Vex(u);
				v2=Locate_Vex(v);
			}
			
			arcs[v1][v2]=w;
			arcs[v2][v1]=w;
			c[i].star=v1;
			c[i].end=v2;
			c[i].weight=w;
		}

		cout<<"无向网构造完成"<<endl;
	}

	void DFS_Traverse()
	{
		for(int i=0;i<vexnum;i++)
			visited[i]=false;
		for(i=0;i<vexnum;i++)
			if(!visited[i])
				DFS(i);
	}

	void DFS(int v)
	{
		visited[v]=true;
		cout<<vexs[v]<<"  ";

		for(int i=0;i<vexnum;i++)
			if(arcs[v][i]<MAX_NUM && !visited[i])
				DFS(i);
	}

	void BFS_Traverse()
	{
		for(int i=0;i<vexnum;i++)
			visited[i]=false;
		for(i=0;i<vexnum;i++)
			if(!visited[i])
				BFS(i);
	}

	void BFS(int v)
	{
		visited[v]=true;
		cout<<vexs[v]<<"  ";

		queue<int> qu;
		int w;
		qu.push(v);

		while(!qu.empty())
		{
			w=qu.front();
			qu.pop();
			for(int i=0;i<vexnum;i++)
			{
				if(arcs[w][i]<MAX_NUM && !visited[i])
				{
					visited[i]=true;
					cout<<vexs[i]<<"  ";
					qu.push(i);
				}
			}
		}
	}

	void KrusKal_Min_Tree(int v,Tree_Edge c2[])
	{
		int i,j,k,u1,v1,sn1,sn2;
		Init(); //初始化并查集

		Quick_Sort(0,arcnum-1);

		k=1;
		j=0;
		while(k<vexnum)
		{
			u1=c[j].star;
			v1=c[j].end;
			sn1=Find(u1); //并查集中查找u1的父亲
			sn2=Find(v1);
			if(sn1 != sn2)
			{
				c2[k]=c[j];
				k++;
				Union(u1,v1); //合并两个集合
			}
			j++;
		}

		cout<<"最小树构造完成"<<endl;
	}

	void Print_Tree(Tree_Edge c2[])
	{
		for(int i=1;i<vexnum;i++)
			cout<<vexs[ c2[i].star ]<<"-->"<<vexs[ c2[i].end ]<<" : "<<c2[i].weight<<endl;
	}
};

void Quick_Sort(int low,int high)
{
	int i,j;
	Tree_Edge t;
	i=low;
	j=high;
	t=c[low];//把第一个元素作为基准
	while(i<j)
	{
		while((i<j)&&(c[j].weight >= t.weight))
			j--;
		if(i<j)
			c[i]=c[j];
		i++;
		while((i<j)&&(c[i].weight <= t.weight))
			i++;
		if(i<j)
			c[j]=c[i];
		j--;
	}
	c[i]=t;
	if(low<high)
	{
		Quick_Sort(low,i-1);//排列t的左边部分
		Quick_Sort(i+1,high);//排列右边部分
	}
}

#endif

#include "graph.h"
#include <iostream>
#include <string>
using namespace std;

int main()
{
	MGraph G;
	G.Create_Graph();
	
	cout<<"图的深度优先遍历为：";
	G.DFS_Traverse();
	cout<<endl;
	
	cout<<"图的广度优先遍历为：";
	G.BFS_Traverse();
	cout<<endl;
	
	string v;
	int pos;
	cout<<"输入建立最小树的起点的名称：";
	cin>>v;
	pos=G.Locate_Vex(v);
	while(pos == -1)
	{
		cout<<"顶点不存在，重新输入：";
		cin>>v;
		pos=G.Locate_Vex(v);
	}
	
	Tree_Edge Edges[MAX_NUM];
	G.KrusKal_Min_Tree(pos,Edges);
	
	cout<<"最小树的边的组成如下所示："<<endl;
	G.Print_Tree(Edges);	

	return 0;
}

测试结果： 

输入定点数目(少于20):  6
输入顶点名称：v1 v2 v3 v4 v5 v6
输入边的总数：10
输入每一条边对应的两个顶点和该边权值：v1 v2 6
输入每一条边对应的两个顶点和该边权值：v1 v3 1
输入每一条边对应的两个顶点和该边权值：v1 v4 5
输入每一条边对应的两个顶点和该边权值：v2 v3 5
输入每一条边对应的两个顶点和该边权值：v3 v4 5
输入每一条边对应的两个顶点和该边权值：v2 v5 3
输入每一条边对应的两个顶点和该边权值：v3 v5 6
输入每一条边对应的两个顶点和该边权值：v3 v6 4
输入每一条边对应的两个顶点和该边权值：v4 v6 2
输入每一条边对应的两个顶点和该边权值：v5 v6 6
无向网构造完成
图的深度优先遍历为：v1  v2  v3  v4  v6  v5
图的广度优先遍历为：v1  v2  v3  v4  v5  v6
输入建立最小树的起点的名称：v1
最小树构造完成
最小树的边的组成如下所示：
v1-->v3 : 1
v4-->v6 : 2
v2-->v5 : 3
v3-->v6 : 4
v2-->v3 : 5
Press any key to continue

下面是测试中生产的无向图 以及生产的最小树：


JKay_Wong
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【算法复习】图的最小生成树（Prim&Kruskal）
qjzl2008的专栏
10-31 8635
所谓生成树就是 如果连通图G的一个子图是一棵包含G的所有顶点的树，则该子图称为G的生成树。 生成树是连通图的包含图中的所有顶点的极小连通子图。 （图的生成树不惟一。从不同的顶点出发进行遍历，可以得到不同的生成树） 而权值最小的树就是最小生成树。 关于生成树最经典的应用模型就是沟通零散点最小造价的问题， 比如网络G表示n各城市之间的通信线路网线路（其中顶点表示城市，边表示两个城市之间
最小生成树之克鲁斯卡尔(Kruskal)算法及其实现
qq_39579087的博客
02-23 852
这里就简单说一下步骤： 先在所有边中选一条权值最小的 检查这条边和结果集中的边是否构成了环，如果构成环，则回到第一步重新选择除这条边外权值最小的边；如果不构成环，那么将这条边加到结果集中 重复上述过程直到所有的点都出现在结果集中 用一个例子来理解： 上图计算最小生成图的步骤如下： 先选AC，AC并没有与结果集中的其他边(此时为空)构成环，因此将AC放到结果集中 选CD，与结果集中的边(AC)不构成环，因此将CD放到结果集中 选AB，同样不构成环，将AB放到结果集中 选AD，此时与结果集中的边构成环(
kruskal 的经典写法 通畅工程之类的题目的模板 最小生成树
Yonggie的博客
05-17 138
主要是给编码看一下这种风格。 主要用了并查集和克鲁斯卡尔最小生成树的算法。 #include <iostream> #include <algorithm> #include<cstdio> #include <stack> #include <fstream> #include <cstring> #include...
Prim算法实现
而塞过的学习之旅
05-16 266
前言 Prim算法在求最小生成树上的一个典型算法 声明：因个人能力有限，本文仅是个人的学习记录笔记，有错误之处还望指出 实现思想 设置两个集合，U集合（在生成树中的结点），V-U集合（不在生成树中的图节点） 选择一个结点作为生成树的结点，并放入U集合 找到与根节点相连权值最小且不在U集合中结点，并加入到U中 重复操作n-1次 代码实现 #include <stdio.h> //最大顶点数 #define MAX 100 //代表无穷大 #define M 32767 /*=.
UFSet并查集的定义与实现
FreeeLinux's blog
11-13 1563
上篇写到集合，干脆把并查集一块写了。 一：什么是并查集 并查集是一种用途广泛的集合，也称为disjoint set，它支持一下3中操作： 1. Union(Root1, Root2)：把子集合Root2并入到集合Root1中。要求Root1和Root2互不相交，否则执行合并。 2.Find(x):搜索单元素x所在的集合，并返回该集合名字。 3.UFSets(s):构造函数，将并查
图论 | 最小生成树——Prim算法和Kruskal算法
weixin_41017788的博客
02-23 246
有权图 表示边的类 // 边 template<typename Weight> class Edge{ private: int a,b; // 边的两个端点 Weight weight; // 边的权值 public: // 构造函数 Edge(int a, int b, Weight weight){ th...
Prim&Kruskal.cpp
最新发布
05-17
Prim&Kruskal.cpp
prim & kruskal
01-03
prim #include #include #include using namespace std; const int N = 510, inf = 0x3f3f3f3f; int g[N][N], dis[N]; int n, m; bool vis[N]; void prim() { memset(dis, 0x3f, sizeof dis); dis[1] = 0; for ...
最小生成树算法Prim & Kruskal
12-24
Prim算法和Kruskal算法是两种常用求解最小生成树的算法。 1. **Prim算法**： Prim算法是从一个顶点开始，逐步扩展生成树，每次添加一条与当前生成树相连且权值最小的边。它以贪心策略为基础，确保每一步都选择...
一个简单的最小生成树（Prim&Kruskal）演示程序
08-01
这个程序是基于Prim算法和Kruskal算法的Java GUI实现，帮助用户直观地理解这两种算法的工作原理。 1. **Prim算法**： Prim算法是一种贪心算法，它从图中的任意一个顶点开始，逐步添加边，每次添加一条与当前生成树...
Prim与Kruskal算法的最小生成树matlab实现
05-26
Prim算法和Kruskal算法是两种常用的求解最小生成树的方法，它们各有特点和适用场景。 1. **Prim算法**： Prim算法是从一个顶点开始，逐步添加边来构建最小生成树。它每次选择与当前树连接且权重最小的边，直到所有...
无向网的最小生成树（Prim算法）
lovecontry
08-15 973
适用于边较为稠密型的连通网 假设N=（V,{VR}）是一个连通网，TE是V上的最小生成树的边的集合，Prim算法从U=｛u0｝(u0∈V) ，TE=｛｝开始，重复执行下面的操作： 在所以的u∈U，v∈V-U的边（u,v）∈VR中找一条权值最小的边（u0,v0）,并入集合TE，同时v0并入U，直至U=V为止。此时TE中必有n-1条边，则T=（V,｛TE｝）为N的最小生成树。为了实现这个算法，需引...
平衡二叉树（AVL树）的基本操作（附有示意图）
热门推荐
Kay's space
08-10 2万+
平衡二叉树关于树的深度是平衡的，具有较高的检索效率。平衡二叉树或是一棵空树，或是具有下列性质的二叉排序树：其左子树和右子树都是平衡二叉树，而且左右子树深度之差绝对值不超过1. 由此引出了平衡因子（balance factor）的概念，bf定义为该结点的左子树的深度减去右子树的深度（有些书是右子树深度减去左子树深度，我是按照左子树减去右子树来计算的，下面的代码也是这样定义的），所以平衡二叉树的结点的
图的几种存储方式
Kay's space
08-05 2万+
之前几天把数据结构扔在一边，在看离散数学的图论部分，看了大部分，最后还是觉得纯数学的，有一些可能现在我刚接触图还不会觉得有什么用，所以就选择性的跳过一些，现在也决定先放下书，回到数据结构上，开始图的部分的学习。 图的存储通用的存储方式有邻接矩阵表示法、邻接表表示法。为方便有向图
Hash表（C++实现）
Kay's space
08-20 1万+
哈希表的几个概念： 映像：由哈希函数得到的哈希表是一个映像。 冲突：如果两个关键字的哈希函数值相等，这种现象称为冲突。 处理冲突的几个方法： 1、开放地址法：用开放地址处理冲突就是当冲突发生时，形成一个地址序列，沿着这个序列逐个深测，直到找到一个“空”的开放地址，将发生冲突的关键字值存放到该地址中去。 例如：hash(i)=(hash(key)+d(i)) MOD m (i=1,2,3,
求AOE网的关键路径
Kay's space
08-18 1万+
以边表示活动，以顶点表示事件的有向网称为AOE(activity on edge)网.AOE网是一个 有向无环图，权值表示活动持续的时间。可以用AOE网来估计工程完成的时间。由于工程 只有一个开始点和一个完成点，所以在无环路的条件下，网中只有一个入度为0的点和一 个出度为0
无向图的深度优先生成树
Kay's space
08-06 1万+
用邻接表存储的无向图的深度优先生成树，树结点用孩子兄弟结构保存。下面是代码 #include #include using namespace std; #define MAX_VERTEX_NUM 20 bool visited[20];//用于遍历时辅助使用 bool s
无向图的广度优先生成树
Kay's space
08-14 1万+
以邻接表为存储结构的无向图的广度优先生成树，以广度优先遍历的思想为主线。下面是代码： #include #include #include using namespace std; const int MAX_VERTEX_NUM=20; //顶点最大值 bool visit
ACM图论算法：最小生成树实现——Prim & Kruskal
文章提到了两种不同的算法：Prim算法和Kruskal算法，并提供了C语言的程序实现。" 在图论中，最小生成树（Minimum Spanning Tree, MST）是一个非常重要的概念，它是在无向图中找到连接所有顶点的边的集合，使得这些...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值