拓扑排序（DFS）

最新推荐文章于 2023-10-16 00:05:41 发布
最新推荐文章于 2023-10-16 00:05:41 发布
阅读量8.7k 收藏 43
点赞数 5
分类专栏： 算法导论(图论)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;
}
不导翁
关注
  • 5
    点赞
  • 踩
  • 43
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
dfs实现拓扑排序原理详解
zhoupingqi2017的博客
05-25 2653
点我跳转 ：传送门
排序算法——拓扑排序(卡恩算法（广度优先）、dfs+深度搜索算法)
yi_chengyu的博客
11-05 5885
文章目录前言一、拓扑排序规则二、卡恩算法实现1.卡恩算法思想2.代码实现三、dfs+深度优先1.算法思想2.代码实现总结 前言 本篇博客主要记录拓扑排序的实现。包括卡恩算法实现和dfs+深度搜索算法实现。其实这两个算法本质分别是广度优先搜索和深度优先搜索。 一、拓扑排序规则 首先知道入度和出度的概念，箭头指向本顶点，则本顶点的入度就+1，箭头指出。则出度+1。 拓扑排序即把出度为0的结点一个一个找出来，看下例子就知道了： 上图中1入度为0，所以1排在前面，此时拓扑排序为{1}，将1指出去的箭头都擦去，.
DFS与BFS|树与图的遍历：拓扑排序
weixin_49449676的博客
04-21 636
蓝色部分是结点4的子树，红色部分我们暂时称为其他部门，因为我们知道树的总结点数n，只要能算出蓝色部分的数目s，那么其他部分的数目就是n-s。若删除结点3，剩下一个数目为1的子树，和一个数目为7的子树，即剩下的最大连通子树的结点数目为7……如这里的1，2，3就是拓扑序列，因为1在2前面，2在3前面，1也在3前面。若删除结点2，则剩下两个数目为1的子树和一个数目为6的子树，即剩下的最大连通子树的结点数目为6；若删除结点1，则剩下三个子树最大的是中间那颗结点有4个，即剩下的最大连通子树的结点数目为4；
拓扑排序（kahn算法和dfs算法）
dztom的博客
11-27 629
拓扑排序（两种算法）
图论（三）：DFS的应用——拓扑排序与强连通分量
qq_45785407的博客
10-26 2317
本节介绍如何使用DFS对有向无环图进行拓扑排序，以及求强连通分量的算法。 一 拓扑排序 什么是拓扑排序呢？对于一个有向无环图G=(V,E)，拓扑排序是G中所有结点的一种线性次序，满足：如果图G包含边(u,v)，则结点u在拓扑排序中处于结点v的前面。拓扑排序可以理解为一系列要处理的事件的先后的顺序。边(u,v)代表完成v必须先完成u。 注意的是：如果图G包含环路，则不可能排出一个线性次序。下图中，图a表示一个有向无环图，图b表示该图的拓扑序。 ...
dfs求拓扑排序+判环
小胡同的诗
08-26 1420
前言 什么是拓扑排序？一个感性的认识是某个开关触发必要的先行条件。例如：一个串联电路形成回路的先行条件是：1，导线联通；2，每个串联分支上联通。假如划分为多个串联分支上也有一个串联路径（实际上就是一条线上串着许多电元件），则整个串联分支联通就递归到多个子分支。 根据上面的描述不难发现这是一个递归的过程，我们应用到图论基于DFS求拓扑排序的思想也类似。综上描述，拓扑排序就是一个图上的遍历序列，序列满...
Golang实现拓扑排序(DFS算法版)
09-18
在本例中，拓扑排序被用来解决一个数字顺序排列的问题，通过定义一个映射关系 `edge` 来表示数字之间的顺序要求，然后使用深度优先搜索(DFS)算法来构建排序序列。 Golang 实现拓扑排序的关键在于理解 DFS 算法。DFS...
拓扑排序
12-22
拓扑排序的结果为DFS后序遍历的倒序。选课是拓扑排序的经典应用场景之一，即：选修一门课程之前须先修完该课程的前置课程。 class Graph(object): def __init__(self, points_nums, is_directed): self.__points_...
top.zip_拓扑排序
09-23
这个文件很可能是实现了一种基本的拓扑排序算法，如深度优先搜索（DFS）或广度优先搜索（BFS）。通常，DFS可以通过回溯找到所有节点的顺序，而BFS则使用队列来确保先访问的节点在前。拓扑排序的步骤包括： 1. 计算图...
top.rar_拓扑排序
09-19
拓扑排序是图论中的一个重要概念，主要用于有向无环图（DAG，Directed Acyclic Graph）。在这个场景中，"top.rar_拓扑排序"是一个使用VC++.NET 2003编写的程序，用于实现拓扑排序算法，并应用于排课问题。排课是一个...
拓扑排序-数据结构-图
06-04
图的拓扑排序 MGraph G; //创建图结构 CreatTu(G); //输出图结构 Disp(G); //排序 Topology(G); disp(G);
tuopupaixu.rar_拓扑排序
09-21
拓扑排序有两种基本算法：深度优先搜索（DFS）和广度优先搜索（BFS）。下面分别介绍这两种方法： 1. **深度优先搜索（DFS）**： - 首先，对图中的所有节点进行访问，标记已访问过的节点。 - 对每个节点，如果它是...
【数据结构——有向图】有环无环判定、拓扑排序（DFS、BFS）
weixin_45618869的博客
09-04 6058
有向图（Directed Graph），也被称为有向图形或方向图，是一种图的类型。在有向图中，图中的边具有方向，从一个顶点指向另一个顶点。在有向图中，每个顶点表示一个实体，而有向边则表示实体之间的关系或连接。这种有方向性的边表明了连接的起点和终点之间的单向关系。因此，有向图中的边具有起点和终点的概念，它们不能逆转方向。与有向图对应的是无向图（Undirected Graph），在无向图中，边是没有方向的，可以双向移动。相比之下，有向图更适合描述具有明确方向性的关系，例如有向的路径、进程之间的依赖关系等。
利用DFS求解有向图的拓扑排序
chenx218的专栏
09-30 3027
深度优先搜索下的拓扑排序
拓扑排序 bfs与dfs实现
Francis的博客
01-08 391
拓扑排序拓扑排序：对一个有向图的顶点进行"排序"。着重点在于图中各个顶点的连接关系，这种连接关系也叫拓扑关系。有向无环图(Directed Acyclic Graph)：若一个图中不存在环...
【数据结构】-图-用DFS实现拓扑排序-环路检测
vector的博客
07-19 3302
void BubbleSort(vector<int> &p, int length,vector<int> &ind_diff) { for (int m = 0; m < length; m++) { ind_diff[m] = m; } for (int i = 0; i < length; i++) { for (int j = 0; j < length - i - 1; j++) { if (p[j] &g.
【Python搜索算法】深度优先搜索（DFS）算法原理详解与应用，示例+代码
热门推荐
qq_35831906的博客
10-16 1万+
深度优先搜索（DFS）是一种重要的图遍历算法，用于探索图中的节点和边。本节介绍DFS算法原理和DFS算法应用案例：解决路径查找问题，解决图的连通性问题：查找下图中的连通组件，拓扑排序，在树结构中进行深度遍历
图基本算法 拓扑排序（基于dfs)
weixin_33753845的博客
05-07 508
　　拓扑排序，是对有向无回路图进行排序，以期找到一个线性序列，这个线性序列在生活正可以表示某些事情完成的相应顺序。如果说所求的图有回路的话，则不可能找到这个序列。 　　在大学数据结构课上，我们知道求拓扑排序的一种方法。首先用一个入度数组保存每个顶点的入度。在进行拓扑排序时，我们需要找到入度为0的点，将其存入线性序列中，再将其从图中删除（与它相关的边都删除，相邻的顶点的入度均减1），再重复上面的操...
拓扑排序解题-DFS解决
qq_41234663的博客
09-03 2714
class Solution { List<List<Integer>> bian; int vis[]; boolean res = true; public boolean canFinish(int numCourses, int[][] prerequisites) { //利用拓扑排序算法 //先构造一个有向图 bian = new ArrayList<List<Integer&gt
拓扑排序 dfsc++
最新发布
10-20
拓扑排序是一种对有向无环图进行排序的算法，它可以用来确定前驱关系，验证图中是否有环等。拓扑排序的基本思想是将图中的节点按照一定的顺序排列，使得所有的有向边从排在前面的节点指向排在后面的节点。在实际应用中，拓扑排序常常被用来解决任务调度、编译顺序等问题。 在C++中，可以使用DFS算法进行拓扑排序。具体实现方法是，对于每个节点，先将其标记为正在访问中，然后遍历其所有的邻居节点，如果邻居节点已经被访问过了，就说明存在环，返回false；如果邻居节点还没有被访问过，就递归地对其进行访问。当所有的邻居节点都被访问完毕后，将该节点标记为已经访问过，并将其加入到拓扑序列中。最后，将拓扑序列倒序输出即可。 下面是一个使用DFS算法进行拓扑排序的C++代码示例： ``` const int maxn = 100; int c[maxn]; int topo[maxn], t, n; int G[maxn][maxn]; bool dfs(int u) { c[u] = -1; for(int v = 0; v < n; v++) { if(G[u][v]) { if(c[v] < 0) return false; else if(!c[v] && !dfs(v)) return false; } } c[u] = 1; topo[--t] = u; return true; } bool topoSort() { t = n; memset(c,0,sizeof(c)); for(int u = 0; u < n; u++){ if(!c[u] && !dfs(u)) return false; } return true; } int main() { char ch[100] = {'a', 'b', 'c', 'd'}; n = 4; G[0][1] = 1; G[2][1] = 1; G[3][2] = 1; if(!topoSort()){ printf("无法拓扑排序\n"); return 0; } for(int i = 0; i < 4; i++){ printf("%c ", ch[topo[i]]); } printf("\n"); } ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值