拓扑排序（DFS）

最新推荐文章于 2024-08-29 09:43:20 发布
最新推荐文章于 2024-08-29 09:43:20 发布
阅读量9.3k 收藏 46
点赞数 7
分类专栏： 算法导论(图论)C/C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45349225/article/details/104810318
版权

拓扑排序如何用DFS实现？？
首先了解DFS生成树，
在这里插入图片描述
根据拓扑排序的定义可以知道，只有图没有环路时才有拓扑排序，由上述DFS生成树可知，当图的DFS生成树没有反祖边时没有环路，这时就可以找出图的拓扑排序（建议画一张图，然后用DFS遍历一遍，就能理解为什么得出拓扑排序）
该算法采用 DFS+栈
首先结构定义

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
const int MaxV = 100;
/*定义栈, 注意栈的数据类型为string*/
typedef struct SNode{
	string *Data;	
	int Top;
	int MaxSize;
} * Stack;
typedef struct ENode{
	int v1, v2;
	string va, vb;
} * Edge;
struct AdjVNode{
	int AdjV;
	AdjVNode *Next;
};
typedef struct VNode{
	string Data;
	bool tag;
	AdjVNode *EdgeFirst;
} AdjList[MaxV];
typedef struct GNode{
	AdjList L;
	int Nv, Ne;
} * LGraph;

栈的需要的操作

/*初始化栈*/
Stack CreateStack(int MaxSize)
{
	Stack S = new SNode;
	S->Data = new string[MaxSize];
	S->MaxSize = MaxSize;
	S->Top = -1;
	return S;
}
/*入栈*/
void Push(Stack S, string x)
{
	S->Data[++S->Top] = x;
}
/*出栈*/
string Pop(Stack S)
{
	return S->Data[S->Top--];
}
/*查找栈中有没有元素x, 并返回在栈中的位置, 如果不在栈中返回-1*/
int FindS(Stack S, string x)
{
	for (int i = S->Top; i >= 0; i--)
		if (S->Data[i] == x)
			return i;
	return -1;
}
/*将边由string型加入对应的int型*/
void Edge_Code(Edge E, Stack S)	//因为这里输入的顶点不再是固定的从0~Nv - 1的编号
{
	int k = FindS(S, E->va);
	if (k < 0) //如果顶点不在栈中, 压入栈
	{
		Push(S, E->va);
		E->v1 = S->Top; //得到新的v1的编号
	}
	else
		E->v1 = k; //得到已有v1的编号
	k = FindS(S, E->vb);
	if (k < 0) //如果顶点不在栈中, 压入栈
	{
		Push(S, E->vb);
		E->v2 = S->Top; //得到新的v2的编号
	}
	else
		E->v2 = k; //得到已有v2的编号
}

图的相关操作

/*初始化邻接表*/
LGraph CreateGraph(int Nv)
{
	LGraph G = new GNode;
	G->Nv = Nv; G->Ne = 0;
	for (int i = 0; i < G->Nv; i++)
	{
		G->L[i].EdgeFirst = NULL;
		G->L[i].tag = false;
	}
	return G;
}
/*插入边操作*/
void InsertEdge(LGraph G, Edge E)
{
	AdjVNode *V = new AdjVNode;
	V->AdjV = E->v2;
	V->Next = G->L[E->v1].EdgeFirst;
	G->L[E->v1].EdgeFirst = V;
}
/*建立新的图, 键盘输入*/
LGraph BuildGraph()
{
	int Nv;
	cin >> Nv;
	LGraph G = CreateGraph(Nv);

	cin >> G->Ne;
	Edge E = new ENode;
	Stack S = CreateStack(G->Nv);
	for (int i = 0; i < G->Ne; i++)
	{
		cin >> E->va >> E->vb;
		Edge_Code(E, S);
		InsertEdge(G, E);
		G->L[E->v1].Data = E->va;
		G->L[E->v2].Data = E->vb;
	}
	delete E;
	delete[] S->Data;
	delete S;
	return G;
}
/*删除图*/
void DeleteGraph(LGraph G)
{
	AdjVNode *V;
	for (int i = 0; i < G->Nv; i++)
		while (G->L[i].EdgeFirst)
		{
			V = G->L[i].EdgeFirst;
			G->L[i].EdgeFirst = V->Next;
			delete V;
		}
	delete G;
}

关键代码，拓扑排序算法

/*拓扑排序DFS算法*/
/*tag: 0表示未访问, 1表示已访问且正常, -1表示已访问但有环*/
bool DFS(LGraph G, int u, Stack S)	//当前DFS函数退出时，下一访问顶点是兄弟或父亲
{									//给予DFS()返回值，false表示有环，true表示无环
	G->L[u].tag = -1;				//if：DFS(i - 1) == false && Tree(i - 1)中没有指向顶点i的边，就有 DFS(i) = false
	AdjVNode *V = G->L[u].EdgeFirst;//							 Tree树是DFS生成树
	while (V)
	{
		if(G->L[V->AdjV].tag == -1)	//此时表明在当前函数下，又回到了u点， 即有回路
			return false;
		if(G->L[V->AdjV].tag == 0 && !DFS(G, V->AdjV, S))	//顶点v没有访问过, 但是v的子节点出现有环，返回错误
			return false;		//有DFS()进入下一递归函数, 作为后判断
		/*函数运行到此处，表示以u为顶点的其中一条边访问完毕，下面进行u的另一条边的访问*/
		V = V->Next;
	}
	/*退出循坏后，表明，而上面没有return，则以u为顶点的*/
	G->L[u].tag = 1;		//对u所有的边访问完后，tag = 1表明正常
	Push(S, G->L[u].Data); 	//注意，入栈是后序（通过前面自己模拟DFS可以明白）
	return true;
}

bool TopSort(LGraph G, Stack S)	//返回值表示是否有拓扑排序, true表示有拓扑排序
{
	for (int i = 0; i < G->Nv; i++)
		if(G->L[i].tag == 0)	//没访问过才访问
			if(!DFS(G, i, S))	//一旦发现有环, 直接退出
				return false;
	return true;
}

实例一
在这里插入图片描述
输入

14 21
w z
v w
p z
p s
o s
p o
n o
o r
s r
o v
v x
y v
r y
r u
n u
u t
q t
n q
m r
m q
m x

在这里插入图片描述
若插入一条有向边<t, m>使之成为一个有环图
在这里插入图片描述
实例二
在这里插入图片描述在这里插入图片描述
输入1

13 15
0 1
0 5
0 6
2 0
2 3
3 5
5 4
6 4
7 6
8 7
6 9
9 10
9 12
9 11
11 12

在这里插入图片描述
输入2

13 22
0 1
0 5
2 0
2 3
3 2
3 5
4 2
4 3
5 4
6 0
6 4
6 9
7 6
7 8
8 7
8 9
9 10
9 11
10 12
11 4
11 12
12 9

在这里插入图片描述
参考
https://zhuanlan.zhihu.com/p/45051460
完整代码

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
const int MaxV = 100;
/*定义栈, 注意栈的数据类型为string*/
typedef struct SNode{
	string *Data;
	int Top;
	int MaxSize;
} * Stack;
typedef struct ENode{
	int v1, v2;
	string va, vb;
} * Edge;
struct AdjVNode{
	int AdjV;
	AdjVNode *Next;
};
typedef struct VNode{
	string Data;
	int tag;
	AdjVNode *EdgeFirst;
} AdjList[MaxV];
typedef struct GNode{
	AdjList L;
	int Nv, Ne;
} * LGraph;
/*初始化栈*/
Stack CreateStack(int MaxSize)
{
	Stack S = new SNode;
	S->Data = new string[MaxSize];
	S->MaxSize = MaxSize;
	S->Top = -1;
	return S;
}
/*入栈*/
void Push(Stack S, string x)
{
	S->Data[++S->Top] = x;
}
/*出栈*/
string Pop(Stack S)
{
	return S->Data[S->Top--];
}
/*查找栈中有没有元素x, 并返回在栈中的位置, 如果不在栈中返回-1*/
int FindS(Stack S, string x)
{
	for (int i = S->Top; i >= 0; i--)
		if (S->Data[i] == x)
			return i;
	return -1;
}
/*将边由string型加入对应的int型*/
void Edge_Code(Edge E, Stack S)
{
	int k = FindS(S, E->va);
	if (k < 0) //如果顶点不在栈中, 压入栈
	{
		Push(S, E->va);
		E->v1 = S->Top; //得到新的v1的编号
	}
	else
		E->v1 = k; //得到已有v1的编号
	k = FindS(S, E->vb);
	if (k < 0) //如果顶点不在栈中, 压入栈
	{
		Push(S, E->vb);
		E->v2 = S->Top; //得到新的v2的编号
	}
	else
		E->v2 = k; //得到已有v2的编号
}
/*初始化邻接表*/
LGraph CreateGraph(int Nv)
{
	LGraph G = new GNode;
	G->Nv = Nv; G->Ne = 0;
	for (int i = 0; i < G->Nv; i++)
	{
		G->L[i].EdgeFirst = NULL;
		G->L[i].tag = 0;
	}
	return G;
}
/*插入边操作*/
void InsertEdge(LGraph G, Edge E)
{
	AdjVNode *V = new AdjVNode;
	V->AdjV = E->v2;
	V->Next = G->L[E->v1].EdgeFirst;
	G->L[E->v1].EdgeFirst = V;
}
/*建立新的图, 键盘输入*/
LGraph BuildGraph()
{
	int Nv;
	cin >> Nv;
	LGraph G = CreateGraph(Nv);

	cin >> G->Ne;
	Edge E = new ENode;
	Stack S = CreateStack(G->Nv);
	for (int i = 0; i < G->Ne; i++)
	{
		cin >> E->va >> E->vb;
		Edge_Code(E, S);
		InsertEdge(G, E);
		G->L[E->v1].Data = E->va;
		G->L[E->v2].Data = E->vb;
	}
	delete E;
	delete[] S->Data;
	delete S;
	return G;
}
/*删除图*/
void DeleteGraph(LGraph G)
{
	AdjVNode *V;
	for (int i = 0; i < G->Nv; i++)
		while (G->L[i].EdgeFirst)
		{
			V = G->L[i].EdgeFirst;
			G->L[i].EdgeFirst = V->Next;
			delete V;
		}
	delete G;
}
/*拓扑排序DFS算法*/
/*tag: 0表示未访问, 1表示已访问且正常, -1表示已访问但有环*/
bool DFS(LGraph G, int u, Stack S)	//当前DFS函数退出时，下一访问顶点是兄弟或父亲
{									//给予DFS()返回值，false表示有环，true表示无环
	G->L[u].tag = -1;				//if：DFS(i - 1) == false && Tree(i - 1)中没有指向顶点i的边，就有 DFS(i) = false
	AdjVNode *V = G->L[u].EdgeFirst;//							 Tree树是DFS生成树
	while (V)
	{
		if(G->L[V->AdjV].tag == -1)	//此时表明在当前函数下，又回到了u点， 即有回路
			return false;
		if(G->L[V->AdjV].tag == 0 && !DFS(G, V->AdjV, S))	//顶点v没有访问过, 但是v的子节点出现有环，返回错误
			return false;		//有DFS()进入下一递归函数, 作为后判断
		/*函数运行到此处，表示以u为顶点的其中一条边访问完毕，下面进行u的另一条边的访问*/
		V = V->Next;
	}
	/*退出循坏后，表明，而上面没有return，则以u为顶点的*/
	G->L[u].tag = 1;		//对u所有的边访问完后，tag = 1表明正常
	Push(S, G->L[u].Data); 	//注意，入栈是后序（通过前面自己模拟DFS可以明白）
	return true;
}

bool TopSort(LGraph G, Stack S)	//返回值表示是否有拓扑排序, true表示有拓扑排序
{
	for (int i = 0; i < G->Nv; i++)
		if(G->L[i].tag == 0)	//没访问过才访问
			if(!DFS(G, i, S))	//一旦发现有环, 直接退出
				return false;
	return true;
}

int main()
{
	LGraph G = BuildGraph();
	Stack S = CreateStack(G->Nv);

	if(!TopSort(G, S))		//如果没有拓扑排序
		cout << "无拓扑排序，存在有向环！" << endl;
	else
	{
		cout << "拓扑排序为:" << endl;
		while (S->Top >= 0)
			cout << Pop(S) << " ";
		cout << endl;
	}

	DeleteGraph(G);
	delete[] S->Data;
	delete S;
	system("pause");
	return 0;
}
不导翁
关注
专栏目录
【数据结构】-图-用DFS实现逆拓扑排序
vector的博客
09-03 4003
DFS实现逆拓扑排序 算法思路： 1.只要某结点还有没有访问的邻接节点，就会继续向下递归调用DFS，不断填充递归栈。 2.没有未访问的邻接结点时，退栈，只要退栈时将节点输出即可 编程注意事项： 用DFS实现拓扑排序（https://blog.csdn.net/qq_39328436/article/details/107450388）以及逆拓扑排序，算法中都是基于DAG图实现的，没有考虑有环的情况。按照这样的方法，在有环的情况下也会输出一个排序，所以更严谨的算法应该增加环路判断。 void D
拓扑排序--dfs
unintended
04-23 461
运用dfs，对一个有向无回图（dag）进行拓扑排序。 一个图的拓扑排序可看成所有顶点沿水平线排列而成的一个序列，使得所有有向边均从左指向右。 TOPOLOGICAL-SORT(G) call DFS(G) to compute finishing times f[v] for each vertex v as each vertex is finished, insert it o
排序算法——拓扑排序(卡恩算法（广度优先）、dfs+深度搜索算法)
yi_chengyu的博客
11-05 6894
文章目录前言一、拓扑排序规则二、卡恩算法实现1.卡恩算法思想2.代码实现三、dfs+深度优先1.算法思想2.代码实现总结 前言 本篇博客主要记录拓扑排序的实现。包括卡恩算法实现和dfs+深度搜索算法实现。其实这两个算法本质分别是广度优先搜索和深度优先搜索。 一、拓扑排序规则 首先知道入度和出度的概念，箭头指向本顶点，则本顶点的入度就+1，箭头指出。则出度+1。 拓扑排序即把出度为0的结点一个一个找出来，看下例子就知道了： 上图中1入度为0，所以1排在前面，此时拓扑排序为{1}，将1指出去的箭头都擦去，.
拓扑排序（思想+代码+示例）
最新发布
weixin_47151388的博客
08-29 2100
了解图谱排序前，我们先了解什么是有向无环图。有向无环图，简称DAG有向图中的每条边都有一个方向，即每条边从一个节点指向另一个节点。例如，如果存在一条边 u→v，这表示从节点 u 指向节点 v。无环图中不存在任何包含多个节点的环路。也就是说，从一个节点出发，通过若干条边可以到达的其他节点中，不可能回到这个出发节点。一个图 G=(V,E)由一组节点 V和一组有向边 E组成。
拓扑排序——DFS
CSDN的博客
08-28 2608
DFS算法 拓扑排序，可以用深度优先搜索来实现，更确切的说，应该是深度优先遍历，遍历途中的所有顶点，而非只是搜索一个顶点到另一个顶点的路径。 注意，此邻接表为逆邻接表。输入的时候需要注意。s —> t，输入时，应该是addEdge(t, s); 然后递归处理每个顶点。对于顶点V来说，先输出祂可达到的所有顶点，也就是说，先把它依赖的所有顶点输出了，再输出自己。 DFS中，每个顶点被访...
拓扑排序-DFS
weixin_30719711的博客
10-05 160
拓扑排序的DFS算法 输入：一个有向图 输出：顶点的拓扑序列 具体流程： (1) 调用DFS算法计算每一个顶点v的遍历完成时间f[v] (2) 当一个顶点完成遍历时，将该顶点放到一个链表的最前面 (3) 返回链表（按照链表次序输出顶点即为顶点的拓扑序列） 样例输入 5 5 0 1 1 0 2 1 1 2 1 2 3 1 4 2 1 样例输出 4 0 1...
拓扑排序dfs实现
fuzekun的博客
06-14 4437
用来进行确定前驱关系。 比如a < b , c < d, c < b 可以确定 a < c < b < d 或者 c < a < b < d 如果没有环的话一定可以存在一条这样的链，但是如果有环就不能进行拓扑排序。这个例子就是不能 a > b 且 b > a; 使用dfs 进行 伪代码 //判断是否有环 bool dfs(u) { 本趟节点标记; for(遍历以u为入弧的定点){ if(是本趟节点）return false;
基于DFS的拓扑排序算法实现
凉城浅离的博客
09-29 2819
拓扑排序，深度优先遍历
Golang实现拓扑排序(DFS算法版)
09-18
在本例中，拓扑排序被用来解决一个数字顺序排列的问题，通过定义一个映射关系 `edge` 来表示数字之间的顺序要求，然后使用深度优先搜索(DFS)算法来构建排序序列。 Golang 实现拓扑排序的关键在于理解 DFS 算法。DFS...
拓扑排序 dfsc++
10-20
在C++中，可以使用DFS算法进行拓扑排序。具体实现方法是，对于每个节点，先将其标记为正在访问中，然后遍历其所有的邻居节点，如果邻居节点已经被访问过了，就说明存在环，返回false；如果邻居节点还没有被访问过，...
浅谈拓扑排序(基于dfs算法）
langzitan123的博客
03-25 4112
假设有n个任务，有m个有序对（u，v)，表示任务u应该排在任务v之前，那么怎样将这些任务按照顺序排列起来呢?比如有三个有序对（1，4），（3，2），（1，3）排列起来就是1，3，2，4 。尽管还有其他可能（如1，4，3，2），但我们只需找出一种即可，注意：有些情况无法排序，如（1，2），（2，3），（3，1）。我们把每个任务看成一个点，将每个有序对看成有向边，则形成了一个有向图，由题意可知这个有向...
拓扑排序(dfs)
艾克
07-23 1191
# include<iostream> # include<cstring> # include<vector> using namespace std; const int maxn=50; typedef struct node{ int adj; //顶点之间的关系 }node; typedef struct graph{ int vert...
拓扑排序 DFS
weixin_58621173的博客
03-05 428
#include <iostream> #include <vector> #include <queue> #include <map> using namespace std; // n代表有n个顶点 m代表有m条边 int n,m; // int G[20] G[0] G[1] G[2]... G[19] -> int // G[0] -> vector<int> 0号顶点所能通向的所有顶点 G[0] = {1,2...
拓扑排序（dfs）
weixin_30539625的博客
04-11 245
问题： 　　对一个有向无环图(Directed Acyclic Graph简称DAG)G进行拓扑排序，是将G中所有顶点排成一个线性序列，使得图中任意一对顶点u和v，若边(u,v)∈E(G)，则u在线性序列中出现在v之前。通常，这样的线性序列称为满足拓扑次序(Topological Order)的序列，简称拓扑序列。简单的说，由某个集合上的一个偏序得到该集合上的一个全序，这个操作称之为拓扑排序。（...
DFS，拓扑排序
a_big_pig的专栏
03-10 1107
DFS伪代码： DFS(G,s)     for each vertex v in V(G)         status[v] = WHITE         /******其他初始化******/     for each vertex v in V(G)         if(status[v]==WHITE)             DFS-VISIT(v)   DFS-VISIT(v)
拓扑排序dfs
qq_40688707的博客
06-05 255
#include&lt;iostream&gt; #include&lt;cstdio&gt; #include&lt;list&gt; #include&lt;vector&gt; using namespace std; const int maxn=1e5+5; vector&lt;vector&lt;int&gt; &gt;g(maxn); b...
基于DFS的拓扑排序
u012148952的博客
05-12 4139
基于 DFS的拓扑排序
拓扑排序基于DFS
qq_41765862的博客
03-13 549
CodeForces - 770C 拓扑排序dfs版+判环 -https://blog.csdn.net/wjh2622075127/article/details/82712940 #include&lt;cstdio&gt; #include&lt;iostream&gt; #include&lt;vector&gt; #include&lt;cstring&gt; #include&...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值