C++实现图的拓扑排序
拓扑排序DFS实现
拓扑排序DFS实现拓扑排序，必须是有向⽆环图。
在任⼀有向⽆环图中，必然存在出度为0的顶点。
否则，每个顶点都⾄少有⼀条出边，这意味着包含环路。
在对有向⽆环图的DFS搜索中，⾸先因访问完成⽽转换⾄VISITED状态的顶点m，其出度必然为0。
基于上述两条特性，我们可以得出结论：DFS搜索过程中各顶点被标记为VISITED的次序，恰好（按逆序）给出了原图的⼀个拓扑排序。
代码：#include <iostream>#include <string>#include <cstdlib>#include <sstream>#include <cstring>#include <cstdio>#include <algorithm>#include <map>#include <math.h>#include <stack>using namespace std;stack<int> s; ///⽤来保存逆序int graph[100][100]; ///邻接矩阵存储，节点从0开始int visited[100];int n; ///节点个数int e; ///⽤来存边的条数void dfs(int v){visited[v] = 1;for(int i=0;i<n;i++){if(graph[v][i]==1&&visited[i]==0){dfs(i);if(visited[i]==1)s.push(i);}}}void solve(){///初始化scanf("%d",&n);scanf("%d",&e);for(int i=0;i<e;i++){int v1,v2;scanf("%d%d",&v1,&v2);graph[v1][v2]=1;}///dfs过程for(int i=0;i<n;i++){if(visited[i]==0){dfs(i);if(visited[i]==1)s.push(i);}}///输出⼊while(!s.empty()){printf("%d ",s.top());s.pop();}}int main() {solve();return0;}。
拓扑排序的原理及其实现
拓扑排序的原理及其实现取材自以下材料：/wiki/Topological_sorting/wiki/Hamiltonian_path定义和前置条件：定义：将有向图中的顶点以线性方式进行排序。
即对于任何连接自顶点u到顶点v的有向边uv，在最后的排序结果中，顶点u总是在顶点v的前面。
如果这个概念还略显抽象的话，那么不妨考虑一个非常非常经典的例子——选课。
我想任何看过数据结构相关书籍的同学都知道它吧。
假设我非常想学习一门“机器学习”的课程，但是在修这么课程之前，我们必须要学习一些基础课程，比如：计算机科学概论，C语言程序设计，数据结构，算法等等。
那么这个制定选修课程顺序的过程，实际上就是一个拓扑排序的过程，每门课程相当于有向图中的一个顶点，而连接顶点之间的有向边就是课程学习的先后关系。
只不过这个过程不是那么复杂，从而很自然的在我们的大脑中完成了。
将这个过程以算法的形式描述出来的结果，就是拓扑排序。
那么是不是所有的有向图都能够被拓扑排序呢？显然不是。
继续考虑上面的例子，如果告诉你在选修“计算机科学概论”这门课之前需要你先学习“机器学习”，你是不是会被弄糊涂？在这种情况下，就无法进行拓扑排序，因为它中间存在互相依赖的关系，从而无法确定谁先谁后。
在有向图中，这种情况被描述为存在环路。
因此，一个有向图能被拓扑排序的充要条件就是它是一个有向无环图(DAG：Directed Acyclic Graph)。
偏序/全序关系：偏序和全序实际上是离散数学中的概念。
这里不打算说太多形式化的定义，形式化的定义教科书上或者上面给的链接中就说的很详细。
还是以上面选课的例子来描述这两个概念。
假设我们在学习完了算法这门课后，可以选修“机器学习”或者“计算机图形学”。
这个“或者”表示，学习“机器学习”和“计算机图形学”这两门课之间没有特定的先后顺序。
因此，在我们所有可以选择的课程中，任意两门课程之间的关系要么是确定的(即拥有先后关系)，要么是不确定的(即没有先后关系)，绝对不存在互相矛盾的关系(即环路)。
图的拓扑排序算法
图的拓扑排序算法图是计算机科学中常用的数据结构之一，它由一些节点（点）和连接这些节点的边（线）组成。
在计算机科学中，图经常被用来解决很多问题，例如计算机网络路由、调度、自然语言处理等等。
其中，图的拓扑排序算法是一个十分重要且广泛应用的算法。
在本文中，我们将详细介绍图的拓扑排序算法的原理及应用。
一、拓扑排序算法简介首先，我们来了解一下什么是拓扑排序算法。
拓扑排序是指将有向无环图(Directed Acyclic Graph, DAG)中节点按照拓扑序列排列的过程。
拓扑序列是指，在排列中，如果存在一条从节点A到节点B的路径，那么在拓扑序列中节点A必须出现在节点B之前。
如果存在环路，则不存在拓扑序列。
拓扑排序算法通常用于任务调度等场景中。
在计算机科学中，拓扑排序算法可以使用两种方法进行实现：基于搜索的算法和基于入度的算法。
二、基于搜索的算法基于搜索的算法是一种比较直接的实现思路，我们可以使用深度优先搜索或者广度优先搜索来实现。
深度优先搜索的方法是，先访问图中入度为0的节点，将其加入拓扑序列中，并将其后继节点的入度减1，直到遍历完整幅图。
基于入度的算法基于入度的算法是另一种有用的实现思路。
首先，我们可以记录每个节点的入度值。
入度是指图中所有指向该节点的边的个数。
对于一个拓扑序列中的节点，它的入度必定为0。
因此，我们可以将入度为0的节点放入队列中，然后对该节点的后继节点的入度减1。
如果减去入度后某个节点的入度为0，则也将其加入队列中。
不断循环这一过程，直到遍历完整幅图。
三、应用场景拓扑排序算法可以在很多场景中应用。
例如，任务调度。
在计算机中，任务调度是指将一些任务分配给不同的处理器进行处理的过程。
我们可以将每个任务看作一个节点，处理器看作边。
拓扑排序算法可以帮助我们找到一个最优的任务调度方案。
另一个应用场景是编译器和依赖管理器。
在编译一个程序时，我们需要按指定顺序编译不同的模块。
如果模块之间存在依赖关系，则需要使用拓扑排序算法来进行模块的编译顺序优化。
【洛谷日报#157】快速入手拓扑排序
【洛⾕⽇报#157】快速⼊⼿拓扑排序⽬录1. 前⾔2. 基本思路3. 模拟思路4.代码实现5. 例题6. 参考⽂献与鸣谢1.前⾔在正式讲拓扑排序之前，我们来引⼊⼀下，以便各位更好理解。
（所有有向图出品于Xmind）⾸先，你想学习计算机的原理怎么办？（⽩⼿起家）肯定有很多前置知识啊！流程图就像下⾯：很明显，此时你需要按⼀定顺序（这个顺序叫 “拓扑序列”）学习才能彻底了解计算机原理。
那么这个顺序怎么求呢？拓扑排序帮你忙！前置知识：图的基本概念以及建图编程能⼒。
2.基本思路 & 实现⾸先，对于点的关系，⼤致分为2种关系：1. 先后关系，如上图的 “数学” 与 “物理学” 的关系。
2. 并列关系（应该叫做“没有关系”），如上图的 ”物理学“ 和 “计算机发展史” 的关系。
不难发现，因为有了并列关系，拓扑序列不⼀定是唯⼀的。
如上图，可以得到很多个拓扑序列，这⾥只举⼀个例⼦，其他的相信⼤家都会看。
上图的⼀个拓扑序列：12345678那么⼤家不难发现，拓扑排序的时候，⼤家总会找⼊度为0的点，因为这是你不⽤学习的点，可以直接解锁。
找到了之后，你就可以把这个点放到序列⾥，那么随之就有新的点的⼊度为0，然后重复上述知道图空。
以上就是拓扑排序的基本思路！我们可以简述为：1. 从图中，选择⼀个⼊度为0的点，并输出该顶点；2. 从图中，删除该顶点，以及相关联的边；3. 重复上述步骤，知道输出所有点。
（原来如此简单！）下⾯带⼤家模拟⼀遍拓扑排序的过程（⼤家觉得烦可以跳过）。
3. 模拟思路⾸先，可以轻易发现，只有点1是⼊度为0，因此，把它输出，删除点1和边A、B。
如下图：糟了，有4个点的⼊度为0怎么办？不着急，由于拓扑序列不⽌⼀个的原因，怎样都⾏，我就按照从⼩到⼤来。
但是为了加快进度，我们直接删掉4个点，并从⼩到⼤⼊拓扑序列，同时删除H、C、E、F、D、G六条边！现在就很明了啦，把点6、7和相关的边删掉，⼊队，再把点8删掉就完⼯！最终拓扑序列：12345678关键来了，怎么⽤代码实现呢？（其实也不考码⼒(>_<)啦）4. 代码实现拓扑排序⼀般有三种实现⽅法（建图是必不可少的）：1. 算法设置⼀个队列（⽅便使⽤优先队列，从⼩到⼤输出）,将所有⼊度为0的顶点⼊队。
数据结构课设——有向图的深度、广度优先遍历及拓扑排序
数据结构课设——有向图的深度、⼴度优先遍历及拓扑排序任务：给定⼀个有向图，实现图的深度优先, ⼴度优先遍历算法，拓扑有序序列，并输出相关结果。
功能要求：输⼊图的基本信息，并建⽴图存储结构（有相应提⽰），输出遍历序列，然后进⾏拓扑排序，并测试该图是否为有向⽆环图，并输出拓扑序列。
按照惯例，先上代码，注释超详细：#include<stdio.h>#include<stdlib.h>#include<malloc.h>#pragma warning(disable:4996)#define Max 20//定义数组元素最⼤个数（顶点最⼤个数）typedef struct node//边表结点{int adjvex;//该边所指向结点对应的下标struct node* next;//该边所指向下⼀个结点的指针}eNode;typedef struct headnode//顶点表结点{int in;//顶点⼊度char vertex;//顶点数据eNode* firstedge;//指向第⼀条边的指针，边表头指针}hNode;typedef struct//邻接表（图）{hNode adjlist[Max];//以数组的形式存储int n, e;//顶点数，边数}linkG;//以邻接表的存储结构创建图linkG* creat(linkG* g){int i, k;eNode* s;//边表结点int n1, e1;char ch;g = (linkG*)malloc(sizeof(linkG));//申请结点空间printf("请输⼊顶点数和边数：");scanf("%d%d", &n1, &e1);g->n = n1;g->e = e1;printf("顶点数：%d 边数：%d\n", g->n, g->e);printf("请输⼊顶点信息（字母）：");getchar();//因为接下来要输⼊字符串，所以getchar⽤于承接上⼀条命令的结束符for (i = 0; i < n1; i++){scanf("%c", &ch);g->adjlist[i].vertex = ch;//获得该顶点数据g->adjlist[i].firstedge = NULL;//第⼀条边设为空}printf("\n打印顶点下标及顶点数据：\n");for (i = 0; i < g->n; i++)//循环打印顶点下标及顶点数据{printf("顶点下标：%d 顶点数据：%c\n", i, g->adjlist[i].vertex);}getchar();int i1, j1;//相连接的两个顶点序号for (k = 0; k < e1; k++)//建⽴边表{printf("请输⼊对<i,j>（空格分隔）：");scanf("%d%d", &i1, &j1);s = (eNode*)malloc(sizeof(eNode));//申请边结点空间s->adjvex = j1;//边所指向结点的位置，下标为j1s->next = g->adjlist[i1].firstedge;//将当前s的指针指向当前顶点上指向的结点g->adjlist[i1].firstedge = s;//将当前顶点的指针指向s}return g;//返回指针g}int visited[Max];//标记是否访问void DFS(linkG* g, int i)//深度优先遍历{eNode* p;printf("%c ", g->adjlist[i].vertex);visited[i] = 1;//将已访问过的顶点visited值改为1p = g->adjlist[i].firstedge;//p指向顶点i的第⼀条边while (p)//p不为NULL时（边存在）{if (visited[p->adjvex] != 1)//如果没有被访问DFS(g, p->adjvex);//递归}p = p->next;//p指向下⼀个结点}}void DFSTravel(linkG* g)//遍历⾮连通图{int i;printf("深度优先遍历;\n");//printf("%d\n",g->n);for (i = 0; i < g->n; i++)//初始化为0{visited[i] = 0;}for (i = 0; i < g->n; i++)//对每个顶点做循环{if (!visited[i])//如果没有被访问{DFS(g, i);//调⽤DFS函数}}}void BFS(linkG* g, int i)//⼴度优先遍历{int j;eNode* p;int q[Max], front = 0, rear = 0;//建⽴顺序队列⽤来存储，并初始化printf("%c ", g->adjlist[i].vertex);visited[i] = 1;//将已经访问过的改成1rear = (rear + 1) % Max;//普通顺序队列的话，这⾥是rear++q[rear] = i;//当前顶点（下标）队尾进队while (front != rear)//队列⾮空{front = (front + 1) % Max;//循环队列，顶点出队j = q[front];p = g->adjlist[j].firstedge;//p指向出队顶点j的第⼀条边while (p != NULL){if (visited[p->adjvex] == 0)//如果未被访问{printf("%c ", g->adjlist[p->adjvex].vertex);visited[p->adjvex] = 1;//将该顶点标记数组值改为1rear = (rear + 1) % Max;//循环队列q[rear] = p->adjvex;//该顶点进队}p = p->next;//指向下⼀个结点}}}void BFSTravel(linkG* g)//遍历⾮连通图{int i;printf("⼴度优先遍历：\n");for (i = 0; i < g->n; i++)//初始化为0{visited[i] = 0;}for (i = 0; i < g->n; i++)//对每个顶点做循环{if (!visited[i])//如果没有被访问过{BFS(g, i);//调⽤BFS函数}}}//因为拓扑排序要求⼊度为0，所以需要先求出每个顶点的⼊度void inDegree(linkG* g)//求图顶点⼊度{eNode* p;int i;for (i = 0; i < g->n; i++)//循环将顶点⼊度初始化为0{g->adjlist[i].in = 0;}for (i = 0; i < g->n; i++)//循环每个顶点{p = g->adjlist[i].firstedge;//获取第i个链表第1个边结点指针while (p != NULL)///当p不为空（边存在）{g->adjlist[p->adjvex].in++;//该边终点结点⼊度+1p = p->next;//p指向下⼀个边结点}printf("顶点%c的⼊度为：%d\n", g->adjlist[i].vertex, g->adjlist[i].in);}void topo_sort(linkG *g)//拓扑排序{eNode* p;int i, k, gettop;int top = 0;//⽤于栈指针的下标索引int count = 0;//⽤于统计输出顶点的个数int* stack=(int *)malloc(g->n*sizeof(int));//⽤于存储⼊度为0的顶点for (i=0;i<g->n;i++)//第⼀次搜索⼊度为0的顶点{if (g->adjlist[i].in==0){stack[++top] = i;//将⼊度为0的顶点进栈}}while (top!=0)//当栈不为空时{gettop = stack[top--];//出栈,并保存栈顶元素（下标）printf("%c ",g->adjlist[gettop].vertex);count++;//统计顶点//接下来是将邻接点的⼊度减⼀，并判断该点⼊度是否为0p = g->adjlist[gettop].firstedge;//p指向该顶点的第⼀条边的指针while (p)//当p不为空时{k = p->adjvex;//相连接的顶点（下标）g->adjlist[k].in--;//该顶点⼊度减⼀if (g->adjlist[k].in==0){stack[++top] = k;//如果⼊度为0，则进栈}p = p->next;//指向下⼀条边}}if (count<g->n)//如果输出的顶点数少于总顶点数，则表⽰有环{printf("\n有回路！\n");}free(stack);//释放空间}void menu()//菜单{system("cls");//清屏函数printf("************************************************\n");printf("* 1.建⽴图 *\n");printf("* 2.深度优先遍历 *\n");printf("* 3.⼴度优先遍历 *\n");printf("* 4.求出顶点⼊度 *\n");printf("* 5.拓扑排序 *\n");printf("* 6.退出 *\n");printf("************************************************\n");}int main(){linkG* g = NULL;int c;while (1){menu();printf("请选择：");scanf("%d", &c);switch (c){case1:g = creat(g); system("pause");break;case2:DFSTravel(g); system("pause");break;case3:BFSTravel(g); system("pause");break;case4:inDegree(g); system("pause");break;case5:topo_sort(g); system("pause");break;case6:exit(0);break;}}return0;}实验⽤图:运⾏结果：关于深度优先遍历 a.从图中某个顶点v 出发，访问v 。
数据结构之拓扑排序算法详解
数据结构之拓扑排序算法详解拓扑排序算法是一种常用于有向无环图（DAG）的排序算法，它可以将图中的顶点按照一定的顺序进行排序，使得图中任意一条有向边的起点在排序结果中都排在终点的前面。
在实际应用中，拓扑排序算法常用于解决任务调度、依赖关系分析等问题。
本文将详细介绍拓扑排序算法的原理、实现方法以及应用场景。
### 一、拓扑排序算法原理拓扑排序算法的原理比较简单，主要包括以下几个步骤：1. 从DAG图中选择一个入度为0的顶点并输出。
2. 从图中删除该顶点以及以该顶点为起点的所有有向边。
3. 重复步骤1和步骤2，直到图中所有顶点都被输出。
### 二、拓扑排序算法实现下面以Python语言为例，给出拓扑排序算法的实现代码：```pythondef topological_sort(graph):in_degree = {v: 0 for v in graph}for u in graph:for v in graph[u]:in_degree[v] += 1queue = [v for v in graph if in_degree[v] == 0] result = []while queue:u = queue.pop(0)result.append(u)for v in graph[u]:in_degree[v] -= 1if in_degree[v] == 0:queue.append(v)if len(result) == len(graph):return resultelse:return []# 测试代码graph = {'A': ['B', 'C'],'B': ['D'],'C': ['D'],'D': []}print(topological_sort(graph))```### 三、拓扑排序算法应用场景拓扑排序算法在实际应用中有着广泛的应用场景，其中包括但不限于以下几个方面：1. 任务调度：在一个任务依赖关系图中，拓扑排序可以确定任务的执行顺序，保证所有任务按照依赖关系正确执行。
拓扑排序与判断有向图是否有回路
拓扑排序与判断有向图是否有回路拓扑排序与判断有向图是否有环⽅式1：基于BFS：采⽤⼊度的⽅式判断是否有回路定义队列Q，将所有⼊度为0的结点加⼊队列取出队列的⾸节点，输出，然后删去从它出发的所有边，并令边的另⼀端结点的⼊度减1，如果减到了0，就将其加⼊队列重复上⾯⼀个操作，直到队列为空。
队列为空时，如果⼊过队列的结点数为N，则拓扑排序成功，图为有向⽆环图；否则图中有环//create on 20210216//拓扑排序；判断图中是否有环//基于判断结点⼊度//邻接表存储；模板#include<iostream>#include<vector>#include<queue>#define maxn 501using namespace std;vector<int> edge[maxn]; //存储每个结点的下⼀个结点（有向图），忽略权重queue<int> q; //保存⼊度为0的结点int indegree[maxn]; //存储每个结点的⼊度int main(){int n,m; //n为结点个数；m为边的个数cin>>n>>m;for(int i=0;i<m;i++){int a,b;cin>>a>>b;edge[a].push_back(b);indegree[b]++;}int cnt = 0;for(int i=1;i<=n;i++){if(indegree[i]==0){q.push(i); //所有⼊度为0的结点进⼊队列cnt++; //统计每个如果队列的结点个数}}while(!q.empty()){int node = q.front();q.pop();for(int i=0;i<edge[node].size();i++){indegree[ edge[node][i] ]--;if(indegree[ edge[node][i] ]==0){q.push(edge[node][i]);cnt++;}}}if(cnt == n) cout<<"NO LOOP"<<endl;else cout<<"LOOP EXISTS"<<endl;return0;}⽅式⼆：基于DFS⼀、基于dfs的拓扑排序（不能处理有环的情况）代码实现：（20191205）/*状态0是还没有被访问状态 1是此次dfs结束，也就是说是最⼩元，后⾯没有结点了，才能被标记为1，然后⼊栈*/#include<iostream>#include<stack>#define inf 9999999using namespace std;int book[101],sum,n,e[101][101];stack<int> s;void dfs (int cur){for(int i=1;i<=n;i++)if(e[cur][i]==1&&book[i]==0)dfs(i);book[cur] = 1;//与DFS的区别在于标记当前节点的时间（在递归结束才加⼊）s.push(cur);return;}int main(){int i,j,m,a,b;cin>>n>>m;for(i=1;i<=n;i++){for(j=1;j<=n;j++){if(i==j) e[i][j]=0;else e[i][j]=inf;}}for(i=1;i<=m;i++){cin>>a>>b;e[a][b]=1;}dfs(2);while(!s.empty()){cout<<s.top()<<"";s.pop();}return0;}View Code测试数据：//左图99242521133638585789//右图781213243426254557View Code⼆、判断有向图是否有环（基于dfs拓扑排序）算法描述：每个结点有三个状态：状态0是还没有被访问；状态-1是在这次dfs过程中被标记；状态 1是此次dfs结束，也就是说是最⼩元（后⾯没有结点了）才能被标记为1；如果与在此次dfs过程中已访问过的结点（状态为-1）有边相连，说明有环（回路）；如果与在此次dfs过程中未访问的结点（状态为0）有边相连，则继续dfs；此次dfs结束后（到最⼩元的结点），将最⼩元的状态标记为1，并且return true（因为此次dfs过程中未出现环）代码实现：（20200129）/*状态0是还没有被访问状态-1是在这次dfs过程中被标记状态 1是此次dfs结束，也就是说是最⼩元，后⾯没有结点了，才能被标记为1*/#include<iostream>#define inf 999999using namespace std;int book[110];int e[110][110];int n;bool dfs (int cur){book[cur] = -1;for(int i=1;i<=n;i++){if(e[cur][i]!=0&&e[cur][i]!=inf&&book[i]==-1)return false;//如果与在此次dfs过程中已访问过的结点（状态为-1）有边相连，说明有环if(e[cur][i]!=0&&e[cur][i]!=inf&&book[i]==0&&!dfs(i))return false;// 如果与在此次dfs过程中未访问的结点（状态为0）有边相连，则继续dfs}book[cur] = 1;//与DFS的区别在于标记当前节点的时间（在递归结束才加⼊）return true;}int main(){cin>>n;for(int i=1;i<=n;i++){for(int j=1;j<=n;j++){if(i==j) e[i][j] = 0;else e[i][j] = inf;}}int m;cin>>m;int a,b,c;for(int i=0;i<m;i++){cin>>a>>b>>c;e[a][b] = c; // directed}bool state = dfs(1);if(state) cout<<"none";else cout<<"exist";return0;}View Code测试数据：//none左图77121131271343453576672//exist右图77211131721343453576672View Code三、基于dfs的拓扑排序（可处理有回路的情况）代码实现：（20191205）/*状态0是还没有被访问状态-1是在这次dfs过程中被标记状态 1是此次dfs结束，也就是说是最⼩元，后⾯没有结点了，才能被标记为1，然后⼊栈*/#include<stdio.h>#include<iostream>#include<stack>#define inf 9999999using namespace std;int book[101],sum,n,e[101][101];stack<int> s;bool dfs (int cur){book[cur] = -1;for(int i=1;i<=n;i++){if(e[cur][i]==1&&book[i]==-1) return false;//如果在这个dfs过程中边相连，说明有环if(e[cur][i]==1&&book[i]==0&&!dfs(i)) return false;}book[cur] = 1;//与DFS的区别在于标记当前节点的时间（在递归结束才加⼊）s.push(cur);return true;}int main(){int i,j,m,a,b;scanf("%d %d",&n,&m);for(i=1;i<=n;i++){for(j=1;j<=n;j++){if(i==j) e[i][j]=0;else e[i][j]=inf;}}for(i=1;i<=m;i++){scanf("%d %d",&a,&b);e[a][b]=1;}bool ans = dfs(2);if(ans == false) cout<<"Loop exists!"<<endl; else{while(!s.empty()){cout<<s.top()<<"";s.pop();}}return0;}View Code测试数据：91024252113363858578981View Code。
数据结构拓扑排序实验报告
数据结构拓扑排序实验报告正文：一、实验目的本实验旨在通过实现拓扑排序算法来加深对数据结构中图的相关概念的理解，掌握拓扑排序的具体步骤与实现方法。
二、实验原理拓扑排序是一种对有向无环图进行排序的算法，它可以将有向无环图的顶点按照线性的顺序排列出来，使得对于任何一个有向边(u, v)，都有顶点 u 在排列中出现在顶点 v 之前。
拓扑排序常用于表示图中的依赖关系，如任务调度、编译顺序等场景。
三、实验步骤1. 构建有向图根据实际需求构建有向图，可以使用邻接表或邻接矩阵等数据结构来表示有向图。
2. 执行拓扑排序算法利用拓扑排序算法对构建的有向图进行排序，可选择使用深度优先搜索（DFS）或广度优先搜索（BFS）等算法实现。
3. 输出排序结果将排序后的顶点按照线性的顺序输出，得到拓扑排序的结果。
四、实验结果与分析1. 实验数据以图 G = (V, E) 的顶点集合 V 和边集合 E，构建了如下的有向图：V = {A, B, C, D, E, F}E = {(A, C), (B, C), (C, D), (D, E), (E, F)}2. 拓扑排序结果经过拓扑排序算法的处理，得到的拓扑排序结果如下： A, B, C, D, E, F3. 结果分析可以看出，根据有向图的依赖关系，拓扑排序算法能够将顶点按照合理的顺序进行排序。
拓扑排序的结果可以作为图中顶点的执行顺序，具有重要的应用价值。
五、实验总结通过本次实验，我们深入学习了拓扑排序算法，并成功实现了拓扑排序的过程。
拓扑排序在图论和数据结构中具有广泛的应用，对于理解和解决与图相关的问题具有重要意义。
六、附件本文档没有涉及附件内容。
七、法律名词及注释本文档没有涉及法律名词及注释。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
#include<iostream>
#include<fstream>
#include<stack>
usingnamespace std;
constint MAX=100;
struct ArcNode
{
int adjVNode; //节点编号
ArcNode *nextArcNode; // 指向邻接到同一节点的其他节点
ArcNode(){nextArcNode=NULL;}
};
struct VNode
{
int num; //节点编号
ArcNode *firstArcNode; //指向该节点邻接的节点
VNode(){firstArcNode=NULL;}
};
struct Graph
{
int vexnum; //图点数
int arcnum; //图边数
VNode vertices[MAX]; //图的邻接表，指针数组
};
bool topSort(Graph G, int *indegree,int *TopNum)
{
int count=0;
stack<int> Q;
for(int i=0;i<G.vexnum;i++)
{
if(indegree[i]==0)
Q.push(i);
}
while(!Q.empty())
{
int u=Q.top();
Q.pop();
TopNum[u]=++count;
ArcNode *p;
for(p=G.vertices[u].firstArcNode;p!=NULL;p=p->nextArcNode)
{
indegree[p->adjVNode]--;
if(indegree[p->adjVNode]==0)
Q.push(p->adjVNode);
}
}
if(count!=G.vexnum)
returnfalse;
returntrue;
}
int main()
{
Graph G;
ifstream fin("in.txt");
cout<<"输入节点数和边数： ";
cin >> G.vexnum >> G.arcnum;
//G.vertices=new VNode[G.vexnum];
for(int i=0;i<G.vexnum;i++)
{
G.vertices[i].num=i;
}
ArcNode *p;
int *indegree=newint[G.vexnum];
for(int i=0;i<G.arcnum;i++)
indegree[i]=0;
for(int i=0;i<G.arcnum;i++)
{
int u,v;
cout<<"第"<<i+1<<"条边：";
//cin >> u >> v;
cin >> u >> v;
p=new ArcNode();
p->adjVNode=v-1;
p->nextArcNode=G.vertices[u-1].firstArcNode;
G.vertices[u-1].firstArcNode=p;
indegree[v-1]++;
//cout << endl;
}
int *TopNum=newint[G.vexnum];
if(topSort(G,indegree,TopNum))
{
for (int i=0;i<G.vexnum-1;i++)
{
cout<<TopNum[i]<<"->";
}
cout<<TopNum[G.vexnum-1]<<endl;
}
system("pause");
return 0;
}。