23、邻接表：BFS实现拓扑排序

最新推荐文章于 2023-12-05 19:38:00 发布

systemyff

最新推荐文章于 2023-12-05 19:38:00 发布

阅读量577

点赞数

分类专栏：数据结构提高25题

本文链接：https://blog.csdn.net/u014377763/article/details/117450641

版权

数据结构提高25题专栏收录该内容

25 篇文章 7 订阅

订阅专栏

问题描述 :

目的：使用C++模板设计并逐步完善图的邻接表抽象数据类型（ADT）。

内容：

（1）请参照图的邻接矩阵模板类原型，设计并逐步完善图的邻接表ADT。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分别放在单独的头文件中。）

（2）设计并实现一个算法，基于广度优先搜索的思想，对于给定的有向图（网），实现拓扑排序。如排序成功，返回true；否则返回false。无论排序是否成功，都请给出最终的排序结果。图的存储结构采用邻接表。将其加入到ADT中。

注意：DG（有向图）, DN（有向网）, UDG（无向图）, UDN（无向网）

提示：可以利用广度优先搜索（BFS）的思想来实现。和普通的广度优先搜索不同的是，一个结点只有当所有可以到达该结点的其它结点都已被访问后才可以被访问。BFS通常借助一个队列来实现，队列中存放的是可以被访问的结点。实现拓扑排序的过程如下：

（1）计算每个结点的入度，保存在数组inDegree中；

（2）检查inDegree中的每个元素，将入度为0的结点入队；

（3）不断从队列中将入度为0的结点出队，输出此结点，并将其对应的visit值赋为1，同时将该结点的入度不为0的后继结点的入度减1；如果某个邻接点的入度为0且未被访问过，则将其入队；

（4）重复步骤3，直到队列为空。如拓扑序列包含了图的全部结点，则排序成功，否则失败。

解题代码：

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <string>
#include <vector>
#include <queue>
#include <sstream>
#include <stack>
#include <map>
#include <ctime>
#include <array>
#include <set>
#include <list>
using namespace std;
//边的定义
template<class TypeOfEdge>
struct Edge_pair
{
	int point = 0;
	TypeOfEdge length = 0;
	//=================
};
//顶点的定义 
template<class TypeOfVer, class TypeOfEdge>
struct verNode
{
	TypeOfVer ver_data;
	list<Edge_pair<TypeOfEdge> > group;
	//构造函数，默认会讲头指针设为空.
	verNode()
	{
		group.clear();
		//ver_data = 0;
	}
	//取得结点值（顶点） 估计是为了安全吧？？？
	TypeOfVer getVer()
	{
		return ver_data;
	}
	//取得对应的边表
	list<Edge_pair<TypeOfEdge> > getHead()
	{
		return group;
	}
	//设置结点值（顶点集） 估计是为了安全吧？？？
	void setdata(TypeOfVer value)
	{
		ver_data = value;
		return;
	}
	//=====================================================

	void creat_Point(int new_point, TypeOfEdge new_length)
	{
		Edge_pair<TypeOfEdge> Next_p;
		Next_p.point = new_point;
		Next_p.length = new_length;
		group.insert(group.begin(), Next_p);
		return;
	}
	//删除指定位置顶点
	void del_Point(int n)
	{

		return;
	}
};

template <class TypeOfVer, class TypeOfEdge>//顶点元素类型，边权值类型
class adjlist_graph {
private:
	int Vers;//顶点数 
	int Edges;//边数 
	vector<verNode<TypeOfVer, TypeOfEdge> >ver;//顶点存储
	string GraphKind;//图的种类标志 
	bool have_dir = false, have_w = false;//图类型参数

	vector<TypeOfVer> dfs_map;
	vector<bool> dfs_vis;
	//======================================================================
	bool Delete_Edge(int u, int v)//删除一条边
	{
		return false;
	}
	bool DFS(int t)//DFS遍历（递归部分）
	{
		dfs_map.push_back(ver[t].ver_data);
		dfs_vis[t] = true;
		for(auto i= ver[t].group.begin();i!= ver[t].group.end();i++)
			if (dfs_vis[i->point] == false)
				DFS(i->point);
		return true;
	}

public:
	//一个空的构造函数
	adjlist_graph()
	{
		Edges = 0;
		Vers = 0;
	}
	//假的析构函数 
	~adjlist_graph()
	{
		;//你电脑内存就640K吗？
	}
	//判断图空否
	bool GraphisEmpty()
	{
		return Vers == 0;
	}
	//获取图的类型
	string GetGraphKind()
	{
		return GraphKind;
	}
	//取得当前顶点数 
	int GetVerNum()
	{
		return Vers;
	}
	//取得当前边数 
	int GetEdgeNum()
	{
		return Edges;
	}
	//自动建立临接表
	bool Auto_build(void)
	{
		//DG（有向图）, DN（有向网）, UDG（无向图）, UDN（无向网）
		/*第一行：图的类型  DN UDN
		第二行：结点数
		第三行：结点集
		第四行：无边标记
		第五行：边数
		第六行：边集
		第七行：权集*/

		/*第一行：图的类型  DG UDG
		第二行：结点数
		第三行：结点集
		第四行：边数
		第五行：边集*/
		cin >> GraphKind;//图的类型 
		cin >> Vers;//结点数
		ver.resize(Vers);//开辟节点空间
		for (int i = 0; i < Vers; i++)//结点集
		{
			TypeOfVer now;
			cin >> now;
			ver[i].setdata(now);
		}


		cin >> Edges;//边数
		vector<int> x_p, y_p, w_p;
		for (int i = 0; i < Edges; i++)
		{
			int c_x, c_y;
			cin >> c_x >> c_y;
			x_p.push_back(c_x);
			y_p.push_back(c_y);
		}
		//图的类型识别

		if (GraphKind == "DG")//DG（有向图）
			have_dir = true, have_w = false;
		if (GraphKind == "DN")//DN（有向网）
			have_dir = true, have_w = true;
		if (GraphKind == "UDG")//UDG（无向图）
			have_dir = false, have_w = false;
		if (GraphKind == "UDN")//UDN（无向网）
			have_dir = false, have_w = true;

		if (have_w)
			for (int i = 0; i < Edges; i++)
			{
				int c_w;
				cin >> c_w;
				w_p.push_back(c_w);
			}


		for (int i = 0; i < Edges; i++)
		{
			if (have_dir)
				if (have_w)
					ver[x_p[i]].creat_Point(y_p[i], w_p[i]);
				else
					ver[x_p[i]].creat_Point(y_p[i], 0);
			else
				if (have_w)
					ver[x_p[i]].creat_Point(y_p[i], w_p[i]), ver[y_p[i]].creat_Point(x_p[i], w_p[i]);
				else
					ver[x_p[i]].creat_Point(y_p[i], 0), ver[y_p[i]].creat_Point(x_p[i], 0);
		}
		return 1;
	}
	//取得G顶点的组
	vector<TypeOfVer> GetVer(void)
	{
		vector<TypeOfVer> head_group;
		for (int i = 0; i < Vers; i++)
		{
			head_group.push_back(ver[i].getVer());
		}
		return head_group;
	}
	//输出邻接表 
	bool Print_photo()
	{
		int i;
		for (i = 0; i < Vers; i++)
		{
			cout << ver[i].getVer();
			if (ver[i].group.size() != 0)
				cout << "->";
			else
			{
				cout << endl;
				continue;
			}
			vector<Edge_pair<TypeOfEdge> > out_lis;
			out_lis.clear();
			for (auto j = ver[i].group.begin(); j != ver[i].group.end(); j++)
			{
				out_lis.push_back(*j);
			}
			int j;
			for (j = 0; j < out_lis.size() - 1; j++)
				if (have_w)
					cout << out_lis[j].point << "(" << out_lis[j].length << ")" << "->";
				else
					cout << out_lis[j].point << "->";
			if (have_w)
				cout << out_lis[j].point << "(" << out_lis[j].length << ")" << endl;
			else
				cout << out_lis[j].point << endl;
		}
		return 1;
	}
	//往G中添加一个顶点 
	bool InsertVer(const TypeOfVer& data)
	{
		verNode<TypeOfVer, TypeOfEdge> new_e;
		new_e.setdata(data);
		ver.push_back(new_e);
		Vers++;
		return true;
	}
	//寻找顶点位置
	int Look_Ver(const TypeOfVer& data)
	{
		int i;
		for (i = 0; i < Vers; i++)
			if (ver[i].ver_data == data)
				return i;
		return -1;
	}
	//删除一个顶点
	bool del_Point(int place)
	{
		int need_del = 0;
		if (!(0 <= place && place < Vers))
			return false;
		int i;
		for (i = 0; i < Vers; i++)
		{
			for (auto j = ver[i].group.begin(); j != ver[i].group.end(); j++)
			{
				if (j->point == place)
				{
					need_del++;
					ver[i].group.erase(j);
					break;
				}
			}
			for (auto j = ver[i].group.begin(); j != ver[i].group.end(); j++)
			{
				if (j->point > place)
					j->point--;
			}
		}
		need_del += ver[place].group.size();
		ver.erase(ver.begin() + place);
		Vers--;
		if (have_dir)
			Edges -= need_del;
		else
			Edges -= (need_del / 2);
		return true;
	}
	//无权图插入一条边
	bool Insert_Edge(int u, int v)
	{
		if (!(0 <= u && u < Vers))
			return false;
		if (!(0 <= v && v < Vers))
			return false;
		for (auto i = ver[u].group.begin(); i != ver[u].group.end(); i++)
		{
			if (i->point == v)
				return false;
		}
		for (auto i = ver[v].group.begin(); i != ver[v].group.end(); i++)
		{
			if (i->point == u)
				return false;
		}
		if (u == v)
			return false;
		if (have_dir)
		{
			Edges++;
			ver[u].creat_Point(v, 1);
			return true;
		}
		else
		{
			Edges++;
			ver[u].creat_Point(v, 1);
			ver[v].creat_Point(u, 1);
			return true;
		}
		return true;
	}
	//有权图插入一条边
	bool Insert_Edge(int u, int v, TypeOfEdge w)
	{
		if (!(0 <= u && u < Vers))
			return false;
		if (!(0 <= v && v < Vers))
			return false;
		for (auto i = ver[u].group.begin(); i != ver[u].group.end(); i++)
		{
			if (i->point == v)
				return false;
		}
		for (auto i = ver[v].group.begin(); i != ver[v].group.end(); i++)
		{
			if (i->point == u)
				return false;
		}
		if (u == v)
			return false;
		if (have_dir)
		{
			Edges++;
			ver[u].creat_Point(v, w);
			return true;
		}
		else
		{
			Edges++;
			ver[u].creat_Point(v, w);
			ver[v].creat_Point(u, w);
			return true;
		}
		return true;
	}
	//删除边 (外壳：有向（删除1条边）， 无向（删除2条边））
	bool del_Edge(int u, int v)
	{
		if (!(0 <= u && u < Vers))
			return false;
		if (!(0 <= v && v < Vers))
			return false;
		if (u == v)
			return false;
		bool ok = true;
		if(have_dir)
			for (auto i = ver[u].group.begin(); i != ver[u].group.end(); i++)
			{
				if (i->point == v)
				{
					ver[u].group.erase(i);
					Edges--;
					return true;
				}
			}
		else
		{
			for (auto i = ver[u].group.begin(); i != ver[u].group.end(); i++)
			{
				if (i->point == v)
				{
					ver[u].group.erase(i);
					break;
				}
			}
			for (auto i = ver[v].group.begin(); i != ver[v].group.end(); i++)
			{
				if (i->point == u)
				{
					ver[v].group.erase(i);
					Edges--;
					return true;
				}
			}
		}
			
		return false;
	}
	//返回G中指定顶点u的第一个邻接顶点的位序（顶点集）。若顶点在G中没有邻接顶点，则返回-1
	int GetFirst_AdjVex(int u)
	{
		if(ver[u].group.empty())
			return -1;
		return ver[u].group.begin()->point;
	}
	//返回G中指定顶点u的下一个邻接顶点（相对于v）的位序（顶点集）。若顶点在G中没有邻接顶点，则返回false
	int GetNext_AdjVex(int u, int v)
	{
		if (ver[u].group.size() == 1)
			return -1;
		for (auto i = ver[u].group.begin(); i != ver[u].group.end(); i++)
		{
			if (i->point == v)
			{
				if ((++i) == ver[u].group.end())
					return -1;
				return i->point;
			}
		}
		return -1;
	}

	//是否存在边
	bool look_Edge(int u, int v)
	{
		if (!(0 <= u && u < Vers))
			return false;
		if (!(0 <= v && v < Vers))
			return false;
		if (u == v)
			return false;
		for (auto i = ver[u].group.begin(); i != ver[u].group.end(); i++)
		{
			if (i->point == v)
				return true;
		}
		for (auto i = ver[v].group.begin(); i != ver[v].group.end(); i++)
		{
			if (i->point == u)
				return true;
		}
		return false;
	}
	//两个顶点之间的边的权值 失败返回-1
	int Get_legthOfEdge(int u, int v)
	{
		if (!have_w)
			return -1;
		if (!(0 <= u && u < Vers))
			return -1;
		if (!(0 <= v && v < Vers))
			return -1;
		if (u == v)
			return -1;
		for (auto i = ver[u].group.begin(); i != ver[u].group.end(); i++)
		{
			if (i->point == v)
				return i->length;
		}
		return -1;
	}
	//获取一个顶点的入度
	int Search_enterDegree(int p)
	{
		if (!(0 <= p && p < Vers))
			return -1;
		if (!have_dir)//is 无向图
			return ver[p].group.size();
		int cnt = 0;
		for (int i = 0; i < Vers; i++)
		{
			if(i!=p)
				for (auto j = ver[i].group.begin(); j != ver[i].group.end(); j++)
				{
					if (j->point == p)
						cnt++;
				}
		}
		//cnt += ver[p].group.size();
		return cnt;
	}
	//获取一个顶点的出度
	int Search_outDegree(int p)
	{
		if (!(0 <= p && p < Vers))
			return -1;
		return ver[p].group.size();
	}
	bool look_haveDir(void)
	{
		return have_dir;
	}
	//DFS遍历（外壳部分）
	void DFS_Traverse(int star)
	{
		dfs_map.clear();
		dfs_vis.clear();
		for (int i = 0; i < Vers; i++)
			dfs_vis.push_back(false);
		DFS(star);
		int i;
		for (i = 0; i < dfs_map.size()-1; i++)
			cout << dfs_map[i] << "->";
		cout << dfs_map[i] << endl;
		return;
	}
	//BFS遍历
	void BFS_Traverse(int star)
	{
		vector<TypeOfVer> bfs_lis;
		vector<bool>bfs_vis;

		bfs_lis.clear();
		bfs_vis.clear();
		for (int i = 0; i < Vers; i++)
			bfs_vis.push_back(false);

		queue<int> Q;
		Q.push(star);
		bfs_vis[star] = true;
		bfs_lis.push_back(ver[star].ver_data);

		int now;
		while (!Q.empty())
		{
			now = Q.front();
			Q.pop();
			for (auto i = ver[now].group.begin(); i != ver[now].group.end(); i++)
					if (bfs_vis[i->point] == false)
					{
						bfs_lis.push_back(ver[i->point].ver_data);
						bfs_vis[i->point] = true;
						Q.push(i->point);
					}
		}
		int i;
		for (i = 0; i < bfs_lis.size() - 1; i++)
			cout << bfs_lis[i] << "->";
		cout << bfs_lis[i] << endl;

		return;
	}
	//是否有路径
	bool Search_way(int star, int v)
	{
		vector<bool>bfs_vis;

		bfs_vis.clear();
		for (int i = 0; i < Vers; i++)
			bfs_vis.push_back(false);

		queue<int> Q;
		Q.push(star);
		bfs_vis[star] = true;

		int now;
		while (!Q.empty())
		{
			now = Q.front();
			if (now == v)
				return true;
			Q.pop();
			for (auto i = ver[now].group.begin(); i != ver[now].group.end(); i++)
				if (bfs_vis[i->point] == false)
				{
					bfs_vis[i->point] = true;
					Q.push(i->point);
				}
		}
		return false;
	}
	//拓扑排序并判断有无回路 0 有 1 无
	bool TopologicalSort(void)
	{
		if (Edges == 0)
			return 0;
		int i, j;
		//将各个顶点的入度存在indegree
		vector<int> indegree;
		indegree.clear();
		//------
		for (i = 0; i < Vers; i++)
			indegree.push_back(Search_enterDegree(i));
		//------
		//入度为0，进栈。
		queue<int> S;
		//------
		for (i = 0; i < indegree.size(); i++)
			if (indegree[i] == 0)
				S.push(i);
		//------
		vector<int> sort_list;//the way of sort
		//BFS
		while (!S.empty())
		{
			int now;
			now = S.front();
			S.pop();
			sort_list.push_back(now);
			int next_p;
			next_p = GetFirst_AdjVex(now);//获取now的第一个相邻的点
			while (next_p != -1)
			{
				--indegree[next_p];
				if (indegree[next_p] == 0)
					S.push(next_p);
				/*if (indegree[next_p] == -1)
					S.push(next_p);*/
				next_p = GetNext_AdjVex(now, next_p);
			}
		}
		if (sort_list.size() == 0)
			return 0;
		//------
		for (i = 0; i < sort_list.size() - 1; i++)
			cout << ver[sort_list[i]].ver_data << "->";
		cout << ver[sort_list[i]].ver_data << endl;
		//------
		if (sort_list.size() < Vers)
			return 0;
		return 1;
	}
};


int main()
{
	int i;
	adjlist_graph<string, int> a;
	a.Auto_build();/*
	int u, v;
	cin >> u >> v;*/
	/*int p;
	cin >> p;*/
	//cout << a.GetGraphKind() << endl;
	vector <string> ans;
	ans = a.GetVer();
	for (i = 0; i < ans.size() - 1; i++)
		cout << ans[i] << " ";
	cout << ans[i] << endl;
	cout << endl;
	//cout << a.GetVerNum() << endl;
	//cout << a.GetEdgeNum() << endl;
	a.Print_photo();
	
	cout << endl;
	if (a.TopologicalSort())
		cout << "true" << endl;
	else
		cout << "false" << endl;


	return 0;
}

systemyff

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
23、邻接表：BFS实现拓扑排序

问题描述 :目的：使用C++模板设计并逐步完善图的邻接表抽象数据类型（ADT）。内容：（1）请参照图的邻接矩阵模板类原型，设计并逐步完善图的邻接表ADT。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分别放在单独的头文件中。）（2）设计并实现一个算法，基于广度优先搜索的思想，对于给定的有向图（网），实现拓扑排序。如排序成功，返回true；否则返回false。无论排序是否成功，都请给出最终的排序结果。图的存储结构采用邻接表。将其加入
复制链接

扫一扫