33 邻接表：BFS实现拓扑排序

最新推荐文章于 2024-08-03 12:30:52 发布

杨骅麟（Patrick Young）

最新推荐文章于 2024-08-03 12:30:52 发布

阅读量416

点赞数

分类专栏：东华大学数据结构OJ 文章标签：宽度优先拓扑学算法

本文链接：https://blog.csdn.net/Ultravioletrays/article/details/125107209

版权

东华大学数据结构OJ 专栏收录该内容

41 篇文章 27 订阅

订阅专栏

33 邻接表：BFS实现拓扑排序

作者: 冯向阳时间限制: 1S章节: DS:图

截止日期: 2022-06-30 23:55:00

问题描述 :

目的：使用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，直到队列为空。如拓扑序列包含了图的全部结点，则排序成功，否则失败。

参考函数原型：

（1）重载形式1

//拓扑排序（仅提供拓扑排序是否成功）

template<class TypeOfVer, class TypeOfEdge>

bool adjlist_graph<TypeOfVer, TypeOfEdge>::TopSort();

（2）重载形式2

//拓扑排序（不仅提供拓扑排序是否成功，排序序列存储在引用参数topsort[]中）

template<class TypeOfVer, class TypeOfEdge>

bool adjlist_graph<TypeOfVer, TypeOfEdge>::TopSort(int &num, int topsort[]);

辅助函数：

//求有向图指定顶点的入度

template<class TypeOfVer, class TypeOfEdge>

int adjlist_graph<TypeOfVer, TypeOfEdge>::Get_InDegree(int u);

图的邻接表模板类原型参考如下：

/* 边表的结点定义 */

template<class TypeOfEdge>

struct edgeNode

{

int data;

TypeOfEdge weight;

edgeNode<TypeOfEdge> *next;

edgeNode(const int &d, edgeNode<TypeOfEdge> *ptr = NULL) //构造函数，用于构造其他结点（无权图）

//函数参数表中的形参允许有默认值，但是带默认值的参数需要放后面

{

next = ptr;

data = d;

}

edgeNode(const int &d, const TypeOfEdge &w, edgeNode<TypeOfEdge> *ptr = NULL) //构造函数，用于构造其他结点（带权图）

//函数参数表中的形参允许有默认值，但是带默认值的参数需要放后面

{

next = ptr;

data = d;

weight = w;

}

int getData(){ return data;} //取得结点的序号（顶点集）

TypeOfEdge getWeight(){ return weight;} //取得边集中对应边的权值

void SetLink( edgeNode<TypeOfEdge> *link ){ next = link; } //修改结点的next域

void SetData( int value ){ data = value; } //修改结点的序号（顶点集）

void SetWeight(TypeOfEdge value ){ weight = value; } //修改边集中对应边的权值

};

//图的邻接表类

template<class TypeOfVer, class TypeOfEdge>

struct verNode

{

TypeOfVer ver;

edgeNode<TypeOfEdge> *head;

verNode(edgeNode<TypeOfEdge> *h = NULL){head = h;}

TypeOfVer getVer(){ return ver;} //取得结点值（顶点集）

edgeNode<TypeOfEdge> *getHead(){ return head;} //取得对应的边表的头指针

void setVer(TypeOfVer value){ ver = value;} //设置结点值（顶点集）

void setHead(edgeNode<TypeOfEdge> *value){ head = value;} //设置对应的边表的头指针

};

template <class TypeOfVer, class TypeOfEdge>

class adjlist_graph{

private:

int Vers; //顶点数

int Edges; //边数

verNode<TypeOfVer,TypeOfEdge> *verList;

string GraphKind; //图的种类标志

bool Delete_Edge( int u, int v );

bool DFS(int u, int &num, int visited[]); //DFS遍历（递归部分）

bool CheckRoute(int u, int v, int visited[]); //检查两个结点之间是否有路径存在（递归部分）

public:

adjlist_graph( const string &kd, int vSize, const TypeOfVer d[]); //构造函数构造一个只有结点没有边的图。

adjlist_graph( const string &kd, int vSize, int eSize, const TypeOfVer d[], int **e); 构造函数构造一个无权图。5个参数的含义：图的类型、结点数、边数、结点集和边集

adjlist_graph( const string &kd, int vSize, int eSize, const TypeOfVer d[], int **e, const TypeOfEdge w[]); //构造函数构造一个有权图。

bool GraphisEmpty() { return Vers == 0; } //判断图空否

string GetGraphKind(){ return GraphKind; }

bool GetVer(int u, TypeOfVer &data); //取得G中指定顶点的值

int GetFirstAdjVex(int u, int &v); //返回G中指定顶点u的第一个邻接顶点的位序（顶点集）。若顶点在G中没有邻接顶点，则返回-1

int GetNextAdjVex(int u, int v, int &w); //返回G中指定顶点u的下一个邻接顶点（相对于v）的位序（顶点集）。若顶点在G中没有邻接顶点，则返回false

bool PutVer(int u, TypeOfVer data); //对G中指定顶点赋值

bool InsertVer(const TypeOfVer &data); //往G中添加一个顶点

int LocateVer(TypeOfVer data); //返回G中指定顶点的位置

bool ExistEdge(int u, int v);

bool PrintVer(); //输出顶点集

bool PrintAdjList(); //输出邻接矩阵

int GetVerNum(){ return Vers;} //取得当前顶点数

int GetEdgeNum(){ return Edges;} //取得当前边数

int Get_Degree(int u); //求指定顶点的（出）度（无向图/网：度；有向图/网：出度）

int Get_InDegree(int u); //求有向图指定顶点的入度

bool GetWeight(int u, int v, int &w); //对于有权图，取两端点为v1和v2的边上的权值。获取成功，返回true；否则，返回false

bool Insert_Edge(int u, int v); //无权图插入一条边

bool Insert_Edge(int u, int v, TypeOfEdge w); //有权图插入一条边

bool DeleteVer(const TypeOfVer &data); //往G中删除一个顶点

bool DeleteEdge( int u, int v ); //删除边 (外壳：有向（删除1条边），无向（删除2条边））

void DFS_Traverse(int u); //DFS遍历（外壳部分）

void BFS_Traverse(int u); //BFS遍历

bool CheckRoute(int u, int v); //检查两个结点之间是否有路径存在（外壳部分）

bool TopSort(); //拓扑排序

~adjlist_graph(); //析构函数

};

输入说明 :

建图的输入数据格式参见建图的算法说明。（以有向图为例，调用重载形式2的函数）

第一行：图的类型

第二行：结点数

第三行：结点集

第四行：边数

第五行：边集

输出说明 :

第一行：顶点集

第二行：邻接表

空行

第三行：拓扑排序结果

第四行：true（排序成功）/false（排序失败）

输入范例 :

DG
8
A B C D E F G H
10
0 2
0 6
1 6
1 7
2 3
3 4
3 6
5 4
6 5
7 5

-------------------

A B C D E F G H

A->6->2->nullptr
B->7->6->nullptr
C->3->nullptr
D->6->4->nullptr
E->nullptr
F->4->nullptr
G->5->nullptr
H->5->nullptr

A->B->C->H->D->G->F->E
true

-------------------

这个真的有点t m难我也是抄抄补补

反正我懒得去想了等有时间再想最近要考试了事情有点多见谅

AC代码

-------------

#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 << "->nullptr" << 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 << ")" <<"->nullptr" << endl;
			else
				cout << out_lis[j].point <<"->nullptr" << 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();
	vector <string> ans;
	ans = a.GetVer();
	for (i = 0; i < ans.size() - 1; i++)
		cout << ans[i] << " ";
	cout << ans[i] << endl;
	cout << endl;
	a.Print_photo();
	cout << endl;
	if (a.TopologicalSort())
		cout << "true" << endl;
	else
		cout << "false" << endl;


	return 0;
}

杨骅麟（Patrick Young）

关注

0
点赞
踩
0

收藏

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

33 邻接表：BFS实现拓扑排序作者: 冯向阳时间限制: 1S章节: DS:图截止日期: 2022-06-30 23:55:00问题描述 :目的：使用C++模板设计并逐步完善图的邻接表抽象数据类型（ADT）。内容：（1）请参照图的邻接矩阵模板类原型，设计并逐步完善图的邻接表ADT。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分别放在单独的头文件中。）（2）设计并实现一个算法，基于广度优先搜索的思想，对于给定的有向图（网），实现拓扑排序。如排
复制链接

扫一扫