数据结构-拓扑排序
数据结构(牛小飞)3 拓扑排序
2021/8/5
25
5
拓扑排序-定义
拓扑排序是对有向无圈图的顶点的一种排序,使 得如果存在一条从vi到vj的路径,那么在排序中vj 就出现在vi的后面。
✓ 显然,如果图中含有圈,那么拓扑排序是不可能的, 因为对于圈上的两个顶点v和w,v优先于w同时w又优 先于v。
2021/8/5
6
拓扑排序-举例
B
A
D
C
不能求得它的拓扑有序序列。
// 对尚未访问的顶点调用DFS
}
while(!Empty(S)) //输出拓扑排序的结果
System.out.print(S.pop());
} 2021/8/5
21
拓扑排序-方法2
void DFS-T(int v) { // 从顶点v出发,深度优先搜索遍历连通图 vertexs[v].visited = true; for(w=FirstAdjVex(v);w>=0; w=NextAdjVex(v,w)) { if (!vertexs[w].visited) DFS-T(w); } // 对v的尚未访问的邻接顶点w递归调用DFS-T S.push(v); //顶点v的DFS函数执行完毕
q.enqueue(v);
while (!q.isEmpty( ) { //如果队列非空
…………
}
if (counter!=NUM_VERTICES) //有圈
throw new CycleFoundException( );
}
2021/8/5
15
拓扑排序-方法1
void topsort( ) throws CycleFoundException { …….
} // DFS-T
拓扑排序的原理及其实现
拓扑排序的原理及其实现取材自以下材料:/wiki/Topological_sorting/wiki/Hamiltonian_path定义和前置条件:定义:将有向图中的顶点以线性方式进行排序。
即对于任何连接自顶点u到顶点v的有向边uv,在最后的排序结果中,顶点u总是在顶点v的前面。
如果这个概念还略显抽象的话,那么不妨考虑一个非常非常经典的例子——选课。
我想任何看过数据结构相关书籍的同学都知道它吧。
假设我非常想学习一门“机器学习”的课程,但是在修这么课程之前,我们必须要学习一些基础课程,比如:计算机科学概论,C语言程序设计,数据结构,算法等等。
那么这个制定选修课程顺序的过程,实际上就是一个拓扑排序的过程,每门课程相当于有向图中的一个顶点,而连接顶点之间的有向边就是课程学习的先后关系。
只不过这个过程不是那么复杂,从而很自然的在我们的大脑中完成了。
将这个过程以算法的形式描述出来的结果,就是拓扑排序。
那么是不是所有的有向图都能够被拓扑排序呢?显然不是。
继续考虑上面的例子,如果告诉你在选修“计算机科学概论”这门课之前需要你先学习“机器学习”,你是不是会被弄糊涂?在这种情况下,就无法进行拓扑排序,因为它中间存在互相依赖的关系,从而无法确定谁先谁后。
在有向图中,这种情况被描述为存在环路。
因此,一个有向图能被拓扑排序的充要条件就是它是一个有向无环图(DAG:Directed Acyclic Graph)。
偏序/全序关系:偏序和全序实际上是离散数学中的概念。
这里不打算说太多形式化的定义,形式化的定义教科书上或者上面给的链接中就说的很详细。
还是以上面选课的例子来描述这两个概念。
假设我们在学习完了算法这门课后,可以选修“机器学习”或者“计算机图形学”。
这个“或者”表示,学习“机器学习”和“计算机图形学”这两门课之间没有特定的先后顺序。
因此,在我们所有可以选择的课程中,任意两门课程之间的关系要么是确定的(即拥有先后关系),要么是不确定的(即没有先后关系),绝对不存在互相矛盾的关系(即环路)。
数据结构的应用的拓扑排序与关键路径算法
数据结构的应用的拓扑排序与关键路径算法拓扑排序与关键路径算法是数据结构中重要的应用之一。
拓扑排序通过对有向图的节点进行排序,使得对于任意一条有向边(u,v),节点 u 在排序中都出现在节点 v 之前。
关键路径算法则是用来确定一个项目的关键活动和最短完成时间。
拓扑排序的实现可以通过深度优先搜索或者广度优先搜索来完成。
深度优先搜索是递归地访问节点的所有未访问过的邻居节点,直到没有未访问过的邻居节点为止,然后将该节点添加到拓扑排序的结果中。
广度优先搜索则是通过使用队列来实现的,将节点的邻居节点逐个入队并进行访问,直到队列为空为止。
无论使用哪种方法,拓扑排序都可以通过判断节点的入度来进行。
拓扑排序在很多实际问题中都有广泛应用。
比如在任务调度中,拓扑排序可以用来确定任务间的依赖关系和执行顺序;在编译原理中,拓扑排序可以用来确定程序中变量的定义和使用顺序。
关键路径算法用于确定项目中的关键活动和最短完成时间。
它通过计算每个活动的最早开始时间和最晚开始时间,以及每个活动的最早完成时间和最晚完成时间来实现。
具体步骤如下:1. 构建有向加权图,其中节点表示项目的活动,有向边表示活动间的先后关系,边的权重表示活动的持续时间。
2. 进行拓扑排序,确定活动的执行顺序。
3. 计算每个活动的最早开始时间,即从起始节点到该节点的最长路径。
4. 计算每个活动的最晚开始时间,即从终止节点到该节点的最长路径。
5. 根据每个活动的最早开始时间和最晚开始时间,可以确定关键活动,即最早开始时间与最晚开始时间相等的活动。
6. 计算整个项目的最短完成时间,即从起始节点到终止节点的最长路径。
拓扑排序与关键路径算法在工程管理、任务调度、生产流程优化等领域都有重要应用。
它们能够帮助我们有效地组织和管理复杂的项目,提高工作效率和资源利用率。
在实际应用中,我们可以借助计算机编程以及各种图算法库来实现这些算法,从而更快速、准确地解决实际问题。
综上所述,拓扑排序与关键路径算法是数据结构的重要应用之一。
数据结构之的拓扑排序算法拓扑排序算法的实现和性能分析
数据结构之的拓扑排序算法拓扑排序算法的实现和性能分析数据结构之拓扑排序算法拓扑排序算法的实现和性能分析拓扑排序是一种常用的图算法,用于对有向无环图(DAG)进行排序。
拓扑排序的主要应用包括任务调度、编译顺序、依赖关系管理等方面。
本文将介绍拓扑排序算法的实现及其性能分析。
一、拓扑排序算法的实现拓扑排序算法一般采用深度优先搜索(DFS)或广度优先搜索(BFS)来实现。
下面将以DFS实现为例进行介绍。
1. 创建图数据结构在进行拓扑排序之前,首先需要创建图的数据结构。
可以使用邻接表或邻接矩阵来表示图。
以邻接表为例,可以使用一个字典来表示每个节点和其相邻节点的关系。
2. 初始化标记数组为了保证每个节点只被访问一次,需要使用一个标记数组来记录节点的访问状态。
可以使用布尔数组或整数数组来表示,将未访问的节点标记为false或0,已访问的节点标记为true或1。
3. 实现拓扑排序函数拓扑排序函数的主要功能是对图进行遍历,并将节点按照拓扑排序的顺序输出。
拓扑排序函数通常使用递归的方式实现。
4. 输出排序结果拓扑排序算法完成后,可以将排序的结果输出。
按照拓扑排序的定义,输出的结果应该是一个拓扑有序的节点列表。
二、拓扑排序算法的性能分析拓扑排序算法的性能取决于图的规模和结构。
下面将从时间复杂度和空间复杂度两个方面进行性能分析。
1. 时间复杂度分析拓扑排序算法的时间复杂度主要取决于图的节点数和边数。
在最坏情况下,每个节点都需要遍历一次,而每个节点的边数是有限的,所以拓扑排序的时间复杂度为O(V+E),其中V表示节点数,E表示边数。
2. 空间复杂度分析拓扑排序算法的空间复杂度主要取决于存储图和标记数组的空间。
在使用邻接表表示图时,需要额外的空间来存储每个节点及其相邻节点的关系。
同时,需要使用标记数组来记录节点的访问状态。
所以拓扑排序的空间复杂度为O(V+E+V),即O(V+E),其中V表示节点数,E表示边数。
三、总结拓扑排序是一种常用的图算法,可以对有向无环图进行排序。
数据结构课设——有向图的深度、广度优先遍历及拓扑排序
数据结构课设——有向图的深度、⼴度优先遍历及拓扑排序任务:给定⼀个有向图,实现图的深度优先, ⼴度优先遍历算法,拓扑有序序列,并输出相关结果。
功能要求:输⼊图的基本信息,并建⽴图存储结构(有相应提⽰),输出遍历序列,然后进⾏拓扑排序,并测试该图是否为有向⽆环图,并输出拓扑序列。
按照惯例,先上代码,注释超详细:#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. 任务调度:在一个任务依赖关系图中,拓扑排序可以确定任务的执行顺序,保证所有任务按照依赖关系正确执行。
数据结构拓扑排序实验报告
数据结构拓扑排序实验报告一、实验目的本次实验的主要目的是深入理解和掌握数据结构中的拓扑排序算法,并通过实际编程实现来验证其有效性和应用场景。
拓扑排序在解决有向无环图(DAG)中的依赖关系问题上具有重要作用,例如任务调度、工程流程规划等。
二、实验环境本次实验使用的编程语言为 Python,开发环境为 PyCharm。
Python具有简洁易懂的语法和丰富的库函数,能够方便地实现拓扑排序算法。
三、实验原理拓扑排序是对有向无环图的顶点进行排序,使得对于图中的每条有向边(u, v),顶点 u 都在顶点 v 之前。
其基本思想是选择一个入度为0 的顶点,将其输出,并删除与其相关的边,从而更新其他顶点的入度,重复这个过程直到图中所有顶点都被输出。
实现拓扑排序的常见方法有两种:基于深度优先搜索(DFS)和基于广度优先搜索(BFS)。
四、实验步骤1、构建有向无环图的数据结构我们使用邻接表来表示有向图,其中每个顶点对应一个列表,存储其指向的顶点。
2、计算顶点的入度遍历邻接表,统计每个顶点的入度。
3、执行拓扑排序基于 BFS 的方法:创建一个队列,将入度为 0 的顶点入队。
然后不断取出队首顶点,输出,并更新与其相邻顶点的入度。
若有新的入度为 0 的顶点,则入队。
基于 DFS 的方法:使用递归函数,从一个未访问的顶点开始,访问其相邻顶点,并在回溯时输出顶点。
4、输出排序结果五、实验代码以下是基于 BFS 实现拓扑排序的 Python 代码示例:```pythonfrom collections import dequeclass Graph:def __init__(self, vertices):selfvertices = verticesselfadjacency_list = for _ in range(vertices)selfindegree = 0 verticesdef add_edge(self, source, destination):selfadjacency_listsourceappend(destination) selfindegreedestination += 1def topological_sort_bfs(self):queue = deque()for vertex in range(selfvertices):if selfindegreevertex == 0:queueappend(vertex)sorted_order =while queue:current_vertex = queuepopleft()sorted_orderappend(current_vertex)for adjacent_vertex in selfadjacency_listcurrent_vertex: selfindegreeadjacent_vertex = 1if selfindegreeadjacent_vertex == 0: queueappend(adjacent_vertex)if len(sorted_order)!= selfvertices:print("Graph contains a cycle Topological sort is not possible")else:print("Topological Sort:", sorted_order)测试示例g = Graph(6)gadd_edge(5, 2)gadd_edge(5, 0)gadd_edge(4, 0)gadd_edge(4, 1)gadd_edge(2, 3)gadd_edge(3, 1)gtopological_sort_bfs()```以下是基于 DFS 实现拓扑排序的 Python 代码示例:```pythonclass Graph:def __init__(self, vertices):selfvertices = verticesselfadjacency_list = for _ in range(vertices) selfvisited = False verticesselfstack =def add_edge(self, source, destination):selfadjacency_listsourceappend(destination) def topological_sort_dfs(self, vertex):selfvisitedvertex = Truefor adjacent_vertex in selfadjacency_listvertex: if not selfvisitedadjacent_vertex: selftopological_sort_dfs(adjacent_vertex) selfstackappend(vertex)def perform_topological_sort(self):for vertex in range(selfvertices):if not selfvisitedvertex:selftopological_sort_dfs(vertex)print("Topological Sort:", selfstack::-1)测试示例g = Graph(6)gadd_edge(5, 2)gadd_edge(5, 0)gadd_edge(4, 0)gadd_edge(4, 1)gadd_edge(2, 3)gadd_edge(3, 1)gperform_topological_sort()```六、实验结果分析1、基于 BFS 的方法对于上述测试示例,输出的拓扑排序结果为 4, 5, 0, 2, 3, 1,符合预期。
数据结构拓扑排序实验报告
数据结构拓扑排序实验报告正文:一、实验目的本实验旨在通过实现拓扑排序算法来加深对数据结构中图的相关概念的理解,掌握拓扑排序的具体步骤与实现方法。
二、实验原理拓扑排序是一种对有向无环图进行排序的算法,它可以将有向无环图的顶点按照线性的顺序排列出来,使得对于任何一个有向边(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. 拓扑排序原理及算法拓扑排序是一种针对有向无环图(DAG)的排序方法,它将图中的顶点按照某种顺序排列,使得图中所有的有向边都满足方向要求。
具体来说,拓扑排序要求在有向边(u,v)中,顶点u必须在顶点v之前。
拓扑排序的基本思想是:从入度为0的顶点开始,将其加入拓扑序列,然后删除该顶点及其所有出边,更新其他顶点的入度。
重复这个过程,直到所有顶点都被加入拓扑序列。
2. 拓扑排序算法实现本次实训中,我们将学习两种拓扑排序算法实现:(1)基于邻接矩阵的拓扑排序首先,我们使用邻接矩阵表示有向图。
然后,遍历邻接矩阵,找出所有入度为0的顶点,将其加入拓扑序列。
接着,删除该顶点及其所有出边,更新其他顶点的入度。
重复这个过程,直到所有顶点都被加入拓扑序列。
(2)基于邻接表的拓扑排序邻接表是一种链式存储结构,它将图中所有顶点存储在一个链表中,每个顶点对应一个链表,链表中存储与该顶点相连的所有顶点。
基于邻接表的拓扑排序算法如下:(1)初始化拓扑序列为空,入度数组为顶点数大小的数组,所有元素的值设为0。
(2)遍历邻接表,找出所有入度为0的顶点,将其加入拓扑序列,并将入度数组中相应元素的值减1。
(3)删除拓扑序列中的顶点及其所有出边,更新入度数组。
(4)重复步骤(2)和(3),直到拓扑序列不为空。
三、实训过程1. 阅读拓扑排序相关资料,了解其原理和算法实现方法。
2. 使用C++编写基于邻接矩阵的拓扑排序程序,实现图数据的构建、拓扑排序和输出拓扑序列。
3. 使用C++编写基于邻接表的拓扑排序程序,实现图数据的构建、拓扑排序和输出拓扑序列。
4. 对比两种算法的优缺点,分析其在实际应用中的适用场景。
5. 运行程序,测试不同图数据的拓扑排序结果,验证程序的正确性。
四、实训总结1. 通过本次实训,我们掌握了拓扑排序的基本原理和算法实现方法,提高了自己在数据结构和算法方面的应用能力。
数据结构-chap7 (4)AOV网与拓扑排序
}//for }//while if (count<G.vexnum) return ERROR; //该有向图有回路 else return OK; }//TopologicalSort
自测题2 AOV-网的拓扑排序
v2 v1 v3 v4 v5 v6 v1 v2
1
3 0 1 0 3 S.top S.base
5 4
1
2 3
3
2 1 4 0 2
C2
1
0
5 0
1
4
5
C3
C4
C5
C3 0 C4
5 0
C5 0
while(! StackEmpty(S)){ Pop(S, i); printf(i, G. vertices[i].data); ++count; for (p=G.vertices[i].firstarc; p; p=p->nextarc) { k = p->adjvex; if ( !(- -indegree[k]) ) Push(S, k); }//for }//while data firstarc C0 1 3 0 栈S C1 5 0
Status TopologicalSort(ALGraph G) { FindInDegree(G, indegree); //求各顶点入度indegree[0..vexnum-1] InitStack(S); for(i=0; i<G. vexnum; ++i) if (! indegree[i]) Push(S, i); //入度为0顶点的编号进栈 count = 0; //对输出顶点计数 count=6 while(! StackEmpty(S)){ Pop(S, i); //从零入度顶点栈S 栈顶,获得一入度为零的顶点i printf(i, G. vertices[i].data); ++count; //输出i号顶点的数据,并计数 for (p=G. vertices[i]. firstarc; p; p=p->nextarc) { k = p->adjvex; if ( !(- -indegree[k]) ) Push(S, k); //对i号顶点邻接到的 每个顶点入度减1
数据结构C语言版_拓扑排序
}
}
p=p->nextarc;
}
printf("\n");
}
}
// 求顶点的入度,算法7.12、7.13调用
void FindInDegree(ALGraph G,int indegree[])
exit(0); // 存储分配失败
(*S).top = (*S).base; // 栈底与栈顶相同表示一个空栈
(*S).stacksize = STACK_INIT_SIZE;
return 1;
}
// 若栈S为空栈(栈顶与栈底相同的),则返回1,否则返回0。
int StackEmpty(SqStack S)
{
int i,j,k;
int w; // 权值
VertexType va,vb;
ArcNode *p;
printf("请输入图的类型(有向图:0,有向网:1,无向图:2,无向网:3): ");
scanf("%d",&(*G).kind);
printf("请输入图的顶点数和边数:(空格)\n");
break;
case DN: printf("有向网\n");
break;
case AG: printf("无向图\n");
break;
case AN: printf("无向网\n");
}
printf("%d个顶点:\n",G.vexnum);
数据结构中的拓扑排序与关键路径问题
数据结构中的拓扑排序与关键路径问题拓扑排序和关键路径问题是数据结构的重要概念和算法之一。
本文将介绍拓扑排序和关键路径问题的背景、定义、应用以及解决方法。
一、背景在计算机科学中,拓扑排序是一种对有向图的所有顶点进行线性排序的算法。
拓扑排序常常用于确定一个计算或任务的顺序,使得所有的前置任务在后置任务之前完成。
而关键路径则用于确定一个项目计划中所需要的最短时间。
二、拓扑排序的定义与应用拓扑排序的目标是找出一个有向无环图(DAG)中所有顶点的一个线性排序,使得对于任意的有向边 (u, v),顶点 u 在排序中都在顶点 v 的前面。
拓扑排序可以用来检测有向图是否有环,并且找出有向无环图中的一个拓扑序列。
拓扑排序广泛应用于诸如编译器设计、任务调度、依赖关系分析等领域。
例如,在编译器设计中,编译器会先进行语法分析,然后根据语法分析的结果进行语义分析,最后完成代码生成。
这个过程可以看作是一个有向图中各个阶段的前置和后置关系,通过拓扑排序就能确定各个阶段的执行顺序。
三、拓扑排序的解决方法拓扑排序有多种解决方法,其中一种常用的方法是使用深度优先搜索(DFS)算法。
在深度优先搜索中,通过递归地访问每个顶点的邻接顶点,并将已经访问过的顶点加入结果列表。
当所有的邻接顶点都被访问过后,将当前顶点加入结果列表的头部。
最后,得到的结果列表就是一个拓扑序列。
四、关键路径问题的定义与应用关键路径问题是指在一个项目中,确定最长路径所需要的时间,即项目的完成时间。
关键路径决定了整个项目的进度,如果关键路径上的任务延误,将导致整个项目延误。
关键路径问题经常用于项目管理、工程造价核算、资源优化等领域。
例如,在一个建筑项目中,确定各个施工任务的完成时间,将有助于安排人力、物力等资源,从而保证项目能够按时交付。
五、关键路径问题的解决方法关键路径问题可以通过构建活动网络图和关键路径分析来解决。
活动网络图是一个有向无环图(DAG),其中顶点表示各个任务,有向边表示任务之间的先后关系。
数据结构拓扑排序实验报告
数据结构拓扑排序实验报告数据结构拓扑排序实验报告一、引言本实验旨在通过实现拓扑排序算法,对给定的有向图进行排序操作。
拓扑排序是一种对有向图进行排序的算法,根据有向边的方向,将图中的节点排列成线性序列,并满足任意一条边的起点在序列中位于终点之前的要求。
二、实验目的1.理解拓扑排序的概念及原理;2.掌握拓扑排序的具体实现方法;3.实现拓扑排序算法,并对给定的有向图进行排序实验。
三、理论知识1.有向图:由一组顶点和一组有向边组成的图结构,每条有向边连接两个顶点,有方向性。
2.有向边:连接有向图中两个顶点的边,表明了两个顶点之间的关系,有起点和终点之分。
3.入度:指向某一顶点的有向边的数量。
4.拓扑排序:一种对有向图进行排序的算法,要求在排序结果中,任意一条边的起点在序列中位于终点之前。
四、实验步骤1.创建图的数据结构,包括顶点和有向边的表示;2.读入有向图的顶点和边的信息,并构建图的结构;3.计算每个顶点的入度,并初始化拓扑排序结果序列;4.选择一个入度为0的顶点,将其加入拓扑排序结果序列,并将其所连接的顶点的入度减1;5.重复步骤4,直到所有顶点被加入拓扑排序结果序列;6.输出最终的拓扑排序结果。
五、实验结果- 给定的有向图:- 图片附件1:有向图示意图- 通过拓扑排序算法得到的排序结果:- 顶点A →顶点B →顶点C →顶点D →顶点E六、实验分析与总结在本次实验中,我们成功实现了拓扑排序算法,并对给定的有向图进行了排序。
通过实验结果可以看出,拓扑排序可以将有向图中的节点按照依赖关系进行排序。
通过拓扑排序,我们可以找到一个满足依赖关系的节点序列,用于解决诸如任务调度、依赖关系分析等问题。
七、附件- 图片附件1:有向图示意图八、法律名词及注释1.有向图:在图论中,有向图是由一组顶点和一组有向边组成的图结构,每条边连接两个顶点,并有方向性。
2.拓扑排序:一种对有向图进行排序的算法,要求在排序结果中,任意一条边的起点在序列中位于终点之前。
数据结构-拓扑排序介绍
成绩14信计 2015-2016(一)数据结构课程设计设计题目拓扑排序设计时间——学生姓名冯佳君学生学号20140401105所在班级14信计 1指导教师刘风华徐州工程学院数学与物理科学学院一、需求剖析1.问题描绘本次课程设计题目是:用毗邻表结构图而后进行拓扑排序,输出拓扑排序序列。
拓扑排序的基本思想为:1)从有向图中选一个无前驱的极点输出;2)将此极点和以它为起点的弧删除;3)重复 1) 、 2) 直到不存在无前驱的极点;4)若此时输出的极点数小于有向图中的极点数,则说明有向图中存在回路,不然输出的极点的次序即为一个拓扑序列。
2.拓扑排序有向图拓朴排序算法的基本步骤以下:1 )从图中选择一个入度为0 的极点,输出该极点;2 )从图中删除该极点及其有关系的弧,调整被删弧的弧头结点的入度(入度-1 );3)重复履行 1)、 2)直到全部极点均被输出,拓朴排序达成或许图中再也没有入度为 0 的极点(此种状况说明原有向图含有环)。
3.基本要求(1)输入的形式和输入值的范围;第一是输入要排序的极点数和弧数,都为整型,中间用分开符分开;再输入各极点的值,为正型,中间用分开符分开;而后输入各条弧的两个极点值,先输入弧头,再输入弧尾,中间用分开符分开,输入的值只好是开始输入的极点值不然系统会提示输入的值的极点值不正确,请从头输入,只需持续输入正确的值就行。
(2)输出的形式;第一输出成立的毗邻表,而后是最后各极点的出度数,再是拓扑排序的序列,而且每输出一个极点,就会输出一次各极点的入度数。
(3)程序所能达到的功能;因为该程序是求拓扑排序,所以算法的功能就是要输出拓扑排序的序列,在一个有向图中,若用极点表示活动,有向边就表示活动间先后次序,那么输出的拓扑序列就表示各极点间的关系为反应出各点的储存结构,以毗邻表储存并输出各极点的入度。
二、纲要设计1.算法顶用到的全部各样数据种类的定义在该程序顶用毗邻表作为图的储存结构。
数据结构名词解释整理
散列表:存放记录的数组拓扑排序: 将一个 DAG 中所有顶点在不违反前置依赖条件规定的基础上排成线性序列的过程称为拓扑排序(44)最差情况:从一个 n 元一维数组中找出一个给定的 K ,如 果数组的最后一个元素是 K ,运行时间会相当长,因为要检查所有 n 个元素,这是算法的最差情况(15)先进先出:队列元素只能从队尾插入,从队首删除(20) (P82)增长率: 算法的增长率是指当输入的值增长时, 算法代价 的增长速率(14)优先队列:一些按照重要性或者优先级来组织的对象成 为优先队列(26)外排序: 考虑到有一组记录因数量太大而无法存放到主存中的问题, 由于记录必须驻留在外存中, 因此这些排序方法称为 外排序(32)连通分量:无向图的最大连通子图称为连通分量(40)栈:是限定仅在一端进行插入或者删除操作的线性表(19)优先队列:一些按照重要性或者优先级来组织的对象为优先队列(26)广度优先搜索:在进一步深入访问其他顶点之前,检查起点的所有相邻顶点(42) 和两个关键码值 k1 和 k2 ,如果k 1) = β k 2),其中β 是表中的一个槽,那末就说 k 1 和 k 2对于 β在散列函数下有冲(35)类型:是指一组值的集合数据类型:一个类型和定义在这个类型上的一组操作(ADT)抽象数据类型:指数据结构作为一个软件构件的实现 数据结构:是 ADT 的实现问题:一个需要完成的任务,即对应一组输入,就有一组相应的输出函数:是输入和输出之间的一种映射关系算法:是指解决问题的一种方法或者一个过程它必须把每一次输入转化为正确的输出;一个算法应该由一系列具体步骤组成,下一步应执行 的步骤必须明确;一个算法必须由有限步组成;算法必须可以终 止。
计算机程序:被认为是使用某种程序设计语言对一个算法的具体实现程序:是算法在计算机程序设计语言中的实现或者元素构成的一个整体递归:如果一个算法调用自己来完成它的部份工作,就称这个算法是递归的渐进分析:可以估算出当问题规模变大时,一种算法及实现它的程序的效率和开消增长率:算法的增长率是指当输入的值增长时,算法代价的增长速率P39)(p43)上限:该算法可能有的最高增长率下限:一种算法消耗某种资源的最大值(p44)线性表:是由称为元素的数据项组成的一种有限且有序的序列栈:是限定仅在一端进行插入或者删除操作的线性表队列:也是一种受限制的线性表,队列元素只能从队尾插入,从队首删除二叉检索树:是满足下面所给出条件的二叉树,该条件即二叉检索树性质:对于二叉检索树的任何一个结点,设其值为K,则该结点左子树中任意一个结点的值都小于K;该结点右子树中任意一个结点的值都大于或者等于K深度:结点M 的深度就是从根节点到M 的路径长度高度:树的高度等于最深结点的深度加1满二叉树:的每一个结点或者是一个分支结点,并恰好有两个非空子结点;或者是叶结点彻底二叉树:有严格的形状要求:从根结点起每一层从左到右填充优先队列:一些按照重要性或者优先级来组织的对象成为优先队列堆:堆由两条性质来定义。
数据结构:第7章 图4-拓扑排序和关键路径
拓扑排序算法
拓扑排序方法: (1)在AOV网中选一个入度为0的顶点(没有前驱) 且输出之; (2)从AOV网中删除此顶点及该顶点发出来的所 有有向边; (3)重复(1)、(2)两步,直到AOV网中所有 顶点都被输出或网中不存在入度为0的顶点。
从拓扑排序步骤可知,若在第3步中,网中所有顶 点都被输出,则表明网中无有向环,拓扑排序成功。 若仅输出部分顶点,网中已不存在入度为0的顶点, 则表明网中有有向环,拓扑排序不成功。
拓扑序列:C1--C2--C3 (3)
C12 C9 C10
C7 C8 C6
C11
拓扑序列:C1--C2--C3--C4 (4)
C7
C12
C12
C8
C8 C9 C10
C6
C9 C10
C6
C11
C11 拓扑序列:C1--C2--C3--C4--C5
(5)
拓扑序列:C1--C2--C3--C4--C5--C7 (6)
在 (b)中,我们用一种有向图来表示课程开设
拓扑排序
1.定义 给出有向图G=(V,E),对于V中的顶点的线性序列 (vi1,vi2,...,vin),如果满足如下条件:若在G中从 顶点 vi 到vj有一条路径,则在序列中顶点vi必在 顶点 vj之前;则称该序列为 G的一个拓扑序列。 构造有向图的一个拓扑序列的过程称为拓扑排序。 2.说明 (1)在AOV网中,若不存在回路,则所有活动可排成 一个线性序列,使得每个活动的所有前驱活动都排 在该活动的前面,那么该序列为拓扑序列. (2)拓扑序列不是唯一的.
2.AOV网实际意义
现代化管理中, 通常我们把计划、施工过程、生产流程、 程序流程等都当成一个工程,一个大的工程常常被划分 成许多较小的子工程,这些子工程称为活动。在整个工 程实施过程中,有些活动开始是以它的所有前序活动的 结束为先决条件的,必须在其它有关活动完成之后才能 开始,有些活动没有先决条件,可以 安排在任意时间开 始。AOV网就是一种可以形象地反映出整个工程中各个 活动之间前后关系的有向图。例如,计算机专业学生的 课程开设可看成是一个工程,每一门课程就是工程中的 活动,下页图给出了若干门所开设的课程,其中有些课 程的开设有先后关系,有些则没有先后关系,有先后关 系的课程必须按先后关系开设,如开设数据结构课程之 前必须先学完程序设计基础及离散数学,而开设离散数 学则必须先并行学完数学、程序设计基础课程。
数据结构课程设计拓扑排序(顺序,逆序输出)
目录一.需求分析说明 (1)二.概要设计说明 (1)三.详细设计说明 (2)四.调试分析 (6)五.用户使用说明 (6)六.课程设计总结 (7)七.测试结果 (8)八.参考书目 (9)九. 附录 (10)一、需求分析说明为了更好的学习数据结构,深刻理解数据结构在解决实际问题中的应用,体会其重要性,熟练掌握线性表、栈和队列、串、数组、树、图等常用的数据结构,熟悉各自的特点和应用场合。
同时锻炼自己独立分析理解问题的能力,学会根据不同的问题选择合适的数据结构,然后结合适当的算法解决问题。
锻炼自己的设计和编写程序的技巧,进一步调试和测试自己所写的程序,使其功能更加完善,养成较好的编写程序习惯。
提高综合运用所学的理论知识和方法独立分析和解决问题的能力,训练用系统的观点和软件开发一般规范进行软件开发,培养软件工作者所应具备的科学的工作方法和作风。
本课程设计的目的就是要达到理论与实际应用相结合,使同学们能够根据数据对象的特性,学会数据组织的方法,能把现实世界中的实际问题在计算机内部表示出来,并培养基本的、良好的程序设计技能。
设计的基本要求:1)选择邻接表作为有向图的存储结构模拟整个过程,并输出拓扑排序的顶点序列。
2)给出逆向的拓扑有序序列。
二、概要设计说明2.1 算法思想采用邻接表存储结构实现有向图;有向图需通过顶点数、边数、顶点以及边等信息建立。
拓扑排序算法大体思想为:1)遍历有向图各顶点的入度,将所有入度为零的顶点入栈;2)栈非空时,输出一个顶点,并对输出的顶点数计数;3)该顶点的所有邻接点入度减一,若减一后入度为零则入栈;4)重复2)、3),直到栈为空,若输出的顶点数与图的顶点数相等则该图可拓扑排序,否则图中有环;5)重复2)、3)、4)直到序列中所有元素均被遍历,则该序列是拓扑序列,否则不是拓扑序列。
2.2 系统功能模块结构图本程序包括拓扑排序模块和拓扑排序核心算法模块。
3.13.2 数据结构1)图typedef struct stack{int *base;int *top;int stacksize;}sqstack;//栈的结构,存储图的顶点序号typedef struct lnode{int adjvex;struct lnode *next;}ArcNode;//弧结点typedef struct node2{int data;ArcNode *fristarc;}VNode,AdjList[MAX];//顶点数组,fristarc指向与顶点邻接的第一条弧typedef struct{AdjList vertices;int vexnum,arcnum;}Graph;//邻接表图void CreatGraph(Graph &G,int *indegree){cout<<"请输入图的顶点数和边数(且顶点数不能超过"<<MAX<<"个)"<<endl;cin>>G.vexnum>>G.arcnum;cout<<"请输入各个顶点值(整形):"<<endl;for(int i=0;i<G.vexnum;i++)//输入图的顶点{cin>>G.vertices[i].data;G.vertices[i].fristarc=NULL;indegree[i]=0;}for(i=0;i<G.arcnum;i++)//输入图的边{int m,n;ArcNode *p;cout<<"请输入第"<<i+1<<"条边的头结点和尾结点:"<<endl;cin>>m>>n;p=new ArcNode;if(!p)exit(0);indegree[n-1]++;//求每个顶点的入度值p->adjvex=n-1;p->next=G.vertices[m-1].fristarc;G.vertices[m-1].fristarc=p;}}2)栈void Initstack(sqstack &s){s.base=new int;if(!s.base)exit(0);s.top=s.base;s.stacksize= STACK_INIT_SIZE;}void Push(sqstack &s,int &e){*s.top++=e;}int Emptystack(sqstack &s){if(s.base==s.top)return 1;elsereturn 0;}int Pop(sqstack &s,int &e){if(s.base==s.top)return ERROR;e=*--s.top;}3.3 具体实现函数1)程序所需头文件及全局变量#include<iostream>using namespace std;const int MAX=30;const int STACK_INIT_SIZE=100;const int ERROR=0;2)栈的操作①void Initstack(sqstack &s)功能:初始化栈,构造一个空栈S参数:S待初始化的栈②i nt Emptystack(sqstack &s)功能:判断栈是否为空参数:S 待判断的栈返回值:栈为空返回1,栈非空返回0③void Push(sqstack &s,int &e)功能:元素入栈参数:S 待操作的栈:插入元素e为新的栈顶元素④int Pop(sqstack &s,int &e)功能:元素出栈参数:S 待操作的栈:若栈不空,则删除S的栈顶元素,用e返回其值,并返回1,否则返回03)图的建立void CreatGraph(Graph &G,int *indegree)功能:建立有向图,并记录每个节点的入度值参数:G 待建立的图:用indegree记录节点的入度值4)拓扑排序int Toposort(Graph &G,int *indegree)功能:对有向图进行拓扑排序,对排序结果进行顺序和逆序输出参数:G 待排序的图:indegree是节点的入度值5)主函数int main()对各个函数进行调用,实现程序功能判断是否排序成功四、调试分析4.1 数据测试1、对存在环的有向图进行测试有向图的顶点数和边数:4 4各顶点的值:1 2 3 4第一条边1 2第二条边的头结点和尾结点:2 3第三条边的头结点和尾结点:3 4第四条边的头结点和尾结点:4 1测试结果:拓扑排序不成功。
第七章--拓扑排序
3 拓扑排序的定义
拓扑排序
拓扑排序就是将AOV网中的所有顶点排列成一个线性序 列,并且满足条件:在AOV网中,如果从顶点vi到顶点vj存在 一条路径,则在该线性序列中,顶点vi一定出现在vj之前。拓 扑排
在有向图中选一个没有前驱(入度为0)的顶点,并且输出之。 从图中删除该顶点和所有以它为尾的弧。
《数据结构》 课程
拓扑排序
主讲教师:李晓娜
目录 CONTENTS
1 问题的导入 2 AOV网的定义 3 拓扑排序的定义 4 拓扑排序的过程
1 问题的导入
例如:我们非常想学习一门计算机 操作系统的课程,但是在修这门 课程之前,我们必须学习一些基 础课,比如程序设计基础、数据 结构、离散数学等等。那么学生 应按怎样的顺序学习这些课程, 才能无矛盾、顺利地完成呢?
课程编号 C1
课程 名称
高等数学
C2
程序设计基础
C3
离散数学
C4
数据结构
C5
算法语言
C6
编译技术
C7
操作系统
C8
普通物理
C9
计算机原理
先修 课程
无
无
C1,C2 C2,C3
C2 C4,C5 C4,C9
C1 C8
1 问题的导入
如何安排学习 计划?
C2
C5
C4 C3
C6
01 AOV网
C1
C8
C7
建立描述课程之间优先关系的有向无环图
重复上述两步,直至全部顶点均已输出;或者当图中不存在无前驱的顶点为止 (此时图中存在环)
V1
V5
拓扑序列:
v0, V1, V2, V3, V4, V5, V6,
数据结构中拓扑排序算法的实现
Ac hi e v e o f To po l o g i c a l Ta x i s Ca l c ul a t i o n i n Da t a St r uc t ur e
LI J i n g
( Gu i z h o u Co mme r c i a l Co U e g e , De p a r t me n t o f Co mp u t e r S c i e n c e a n d T e c h n o l o g y, Gu i y ng a 5 5 0 0 0 4, Ch i n a )
电脑 编程技巧 与维 护 源自数 据结构 中拓 扑排序算 法 的实现
奎 静
( 贵州商业高等专科学校计算机科学与技术系 ,贵阳 5 5 o o o 4 ) 摘 要 :介绍拓扑排序 的算 法,对 于给 出的事件 结点 网络 ,要求依 次求 出入度 ( 或 出度)为 0的顶 点 ,最终得 到一
组拓 扑序 列。通过 对这 一序 列的分析 、比较 ,判 断该 网络 图是否 为循环 图 ,从 而确立 实际应 用的可能性 大小 ,并给 出了计算机 上机 实现 的源程序 。 关键 词 :拓 扑序 列 ; A O E网 ; 数据结构
又如 ,汽车装 配工 程可分解为 以下任 务 :将底盘 放上装配线 ,
装轴 ,将 座位 装在底 盘上 、上 漆 、装 刹车 、装 门等 。任 务之 间具有先后关 系 ,例如在装轴之前必 须先将底板 放上装配线 。
要来 描 述 这 些任 务 的先 后 顺序 就可 用 A O V网 ( A c t i v i t y O n
这些 事件 都可分 为若干个 子事件 ,只要 依次完 成它 们 ,就 可 以最终促 成整个事 件 的完 成 。但这 些子 事件之 间有 时存 在一 定的先决 条件 约束 ,即有 些子事 件必 须在其他 子事 件完 成 以 后方可 开始实施 ;而有些 子事件 则没有 这样 的约束 关 系。例 如 :将早 晨穿 衣的过程看 作是一 项小 工程 。那 必须 先穿 某一 衣物才 能再穿 其他衣物 ( 如先穿 袜子后 穿鞋) ,逐 步完成 工程 的运作 ,也有一些 衣物可以按任意次序穿戴 ( 如袜子 和短裤) 。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
14信计2015-2016(一)数据结构课程设计设计题目拓扑排序设计时间2016.1.11——2016.1.15学生姓名冯佳君学生学号20140401105所在班级14信计1指导教师刘风华徐州工程学院数学与物理科学学院一、需求分析1.问题描述本次课程设计题目是:用邻接表构造图然后进行拓扑排序,输出拓扑排序序列。
拓扑排序的基本思想为:1)从有向图中选一个无前驱的顶点输出;2)将此顶点和以它为起点的弧删除;3) 重复1)、 2)直到不存在无前驱的顶点;4) 若此时输出的顶点数小于有向图中的顶点数,则说明有向图中存在回路,否则输出的顶点的顺序即为一个拓扑序列。
2.拓扑排序有向图拓朴排序算法的基本步骤如下:1)从图中选择一个入度为0的顶点,输出该顶点;2)从图中删除该顶点及其相关联的弧,调整被删弧的弧头结点的入度(入度-1);3)重复执行1)、2)直到所有顶点均被输出,拓朴排序完成或者图中再也没有入度为0的顶点(此种情况说明原有向图含有环)。
3.基本要求(1)输入的形式和输入值的范围;首先是输入要排序的顶点数和弧数,都为整型,中间用分隔符隔开;再输入各顶点的值,为正型,中间用分隔符隔开;然后输入各条弧的两个顶点值,先输入弧头,再输入弧尾,中间用分隔符隔开,输入的值只能是开始输入的顶点值否则系统会提示输入的值的顶点值不正确,请重新输入,只要继续输入正确的值就行。
(2)输出的形式;首先输出建立的邻接表,然后是最终各顶点的出度数,再是拓扑排序的序列,并且每输出一个顶点,就会输出一次各顶点的入度数。
(3) 程序所能达到的功能;因为该程序是求拓扑排序,所以算法的功能就是要输出拓扑排序的序列,在一个有向图中,若用顶点表示活动,有向边就表示活动间先后顺序,那么输出的拓扑序列就表示各顶点间的关系为反映出各点的存储结构,以邻接表存储并输出各顶点的入度。
二、概要设计1. 算法中用到的所有各种数据类型的定义在该程序中用邻接表作为图的存储结构。
首先,定义表结点和头结点的结构类型,然后定义图的结构类型。
创建图用邻接表存储的函数,其中根据要求输入图的顶点和边数,并根据要求设定每条边的起始位置,构建邻接表依次将顶点插入到邻接表中。
拓扑排序的函数在该函数中首先要对各顶点求入度,其中要用到求入度的函数,为了避免重复检测入度为零的顶点,设置一个辅助栈,因此要定义顺序栈类型,以及栈的函数:入栈,出栈,判断栈是否为空。
2.各程序模块之间的层次调用关系第一部分,void ALGraph *G函数构建图,用邻接表存储。
这个函数没有调用函数。
第二部分,void TopologicalSort(ALGraph *G)输出拓扑排序函数,这个函数首先调用FindInDegree(G,indegree)对各顶点求入度indegree[0……vernum-1];然后设置了一个辅助栈,调用InitStack(&S)初始化栈,在调用Push(&S,i)入度为0者进栈,while(!StackEmpty(&S))栈不为空时,调用Pop(&sS,&n)输出栈中顶点并将以该顶点为起点的边删除,入度indegree[k]--,当输出某一入度为0的顶点时,便将它从栈中删除。
第三部分,主函数,先后调用void CreatGraph(ALGraph *G)函数构建图、void TopologicalSort(ALGraph *G)函数输出拓扑排序实现整个程序。
3.设计的主程序流程(见附页)流程图::三、详细设计(实现概要设计中定义的所有数据类型,对每个操作写出伪码算法;对主程序和其他模块也都需要写出伪码算法(伪码算法达到的详细程度建议为;按照伪码算法可以在计算机键盘直接输入高级程序设计语言程序);写出出函数和过程的调用关系。
)1.实现概要设计中定义的所有数据类型#include<stdio.h>#include<stdlib.h>#define MAX_VEXTEX_NUM 100#define STACK_INIT_SIZE 100#define STACKINCREMENT 10#define OK 1#define M 100#define ERROR 0typedef int ElemType;typedef struct ArcNode{int adjvex;struct ArcNode *nextarc;}ArcNode;typedef struct VNode{int data;ArcNode *firstarc;}VNode,AdjList[MAX_VEXTEX_NUM];typedef struct{AdjList vertices;int vexnum, arcnum;}ALGraph;typedef struct{ElemType *base;ElemType *top;int stacksize;}SqStack;2.算法和各模块的代码程序中各函数算法思想如下:2.1 void InitStack(SqStack *S)初始化栈将栈的空间设为 STACK-INIT-SIZE。
2.2 int Pop(SqStack *S,ElemType *e)出栈操作,若站不空,删除S的栈顶元素,用e返回其值,并返回OK;否则返回ERROR。
2.3 void Push(SqStack *S,ElemType e)进栈操作,插入元素e为新的栈顶元素。
2.4 int StackEmpty(SqStack *S)判断栈是否为空,语句if (S->top=S->base )判断,若栈不为空,则删除S 的栈顶元素,并返回OK;否则返回ERROR。
2.5 void CreatGraph (ALGraph *G)构建图,用邻接表存储,首先定义邻接表指针变量,输入顶点数和弧数,初始化邻接表,将表头向量域置空,输入存在弧的点集合,当输入顶点值超出输入值的范围就会出错,否则依次插入进邻接表,最后输出建立好的邻接表。
2.6 void FindInDegree(ALGrap G, int indegreee[])求入度操作,设一个存放各顶点入度的数组indegreee[],然后indegreee[i]=0赋初值,for循环indegreee[]++,存储入度数。
2.7 void TopologicalISort(ALGraph G)输出拓扑排序函数。
其思路是若G无回路,则输出G的顶点的一个拓扑序列并返回OK,否则返回ERROR。
首先由于邻接表的存储结构入度为零的顶点即为没有前驱的顶点,我们可以附设一个存放个顶点入度的数组,调用FindInDegree( G, indegreee[])对各顶点求入度;为了避免重复检测入度为零0的顶点,设置一个栈,调用InitStack(&S)初始化栈,在调用Push(&S,i)入度为0者进栈,while(!StackEmpty(&S))栈不为空时,调用Pop(&sS,&n)输出栈中顶点并将以该顶点为起点的边删除,入度indegree[k]--,当输出某一入度为0的顶点时,便将它从栈中删除。
3.算法的时间复杂度和空间复杂度拓扑排序实际是对邻接表表示的图G进行遍历的过程,每次访问一个入度为零的顶点,若图G中没有回路,则需扫描邻接表中的所有边结点,在算法开始时,为建立入度数组D需访问表头向量中的所有边结点,算法的时间复杂度为O(n+e)。
四、测试与分析输入:结果如下:五、总结拓扑排序就是对一个有向无环图(Directed Acyclic Graph简称DAG)G进行拓扑排序,是将G中所有顶点排成一个线性序列,使得图中任意一对顶点u和v,若<u,v> ∈E(G),则u在线性序列中出现在v之前。
在进行课程设计中,更好的认识了拓扑排序。
理清了各个模块之间算法之间的条理。
认识了伪代码(Pseudocode)是一种算法描述语言。
使用伪代码的目的是为了使被描述的算法可以容易地以任何一种编程语言(Pascal,C,Java,etc)实现。
因此,伪代码必须结构清晰、代码简单、可读性好,并且类似自然语言。
介于自然语言与编程语言之间。
它是一种让人便于理解的代码。
不依赖于语言的,用来表示程序执行过程,而不一定能编译运行的代码。
在数据结构讲算法的时候用的很多。
在设计中,我们遇到了程序正确,却对某些无向图无法进行拓扑排序的问题。
多次对程序进行修改后,才可以进行拓扑排序。
问题出在调用函数的错误理解,模块之间的联系模糊不清。
附录:源程序:#include<stdio.h>#include<stdlib.h>#define MAX_VEXTEX_NUM 100#define STACK_INIT_SIZE 100#define STACKINCREMENT 10#define OK 1#define M 100#define ERROR 0typedef int ElemType;typedef struct ArcNode{int adjvex;struct ArcNode *nextarc;}ArcNode;typedef struct VNode{int data;ArcNode *firstarc;}VNode,AdjList[MAX_VEXTEX_NUM];typedef struct{AdjList vertices;int vexnum, arcnum;}ALGraph;typedef struct{ElemType *base;ElemType *top;int stacksize;}SqStack;void InitStack(SqStack *);int Pop(SqStack *, ElemType *);void Push(SqStack *,ElemType );int StackEmpty(SqStack *);void CreatGraph(ALGraph *);void FindInDegree(ALGraph , int * );void TopologicalSort(ALGraph );void InitStack(SqStack *S){S->base=(ElemType *)malloc(STACK_INIT_SIZE*sizeof(ElemType)); if(!S->base){printf("内存分配失败,请检查储存位置,再见");exit(1);}S->top=S->base;S->stacksize=STACK_INIT_SIZE;}int Pop(SqStack *S,ElemType *e){if(S->top==S->base){return ERROR;}*e=*--S->top;return 0;}void Push(SqStack *S,ElemType e){if(S->top-S->base>=S->stacksize){S->base = (ElemType *)realloc(S->base,(S->stacksize+STACKINCREMENT)*sizeof(ElemType)); if(!S->base){printf("内存分配失败,请检查储存位置,再见");exit(1);}S->top = S->base+S->stacksize;S->stacksize+=STACKINCREMENT;}*S->top++=e;}int StackEmpty(SqStack *S){if(S->top==S->base)return OK;elsereturn ERROR;}void CreatGraph(ALGraph *G){int m, n, i;ArcNode *p;printf("请输入顶点数和边数:");scanf("%d%d",&G->vexnum,&G->arcnum);for (i = 1; i <= G->vexnum; i++){G->vertices[i].data = i;G->vertices[i].firstarc = NULL;}for (i = 1; i <= G->arcnum; i++){printf("\n请输入存在边的两个顶点的序号,先输入弧尾,再输入弧头:"); scanf("%d%d",&n,&m);while (n < 0 || n > G->vexnum || m < 0 || m > G->vexnum){printf("输入的顶点序号不正确请重新输入:");scanf("%d%d",&n,&m);}p = (ArcNode*)malloc(sizeof(ArcNode));if (p == NULL){printf("内存分配失败,请检查储存位置,再见");exit(1);}p->adjvex = m;p->nextarc = G->vertices[n].firstarc;G->vertices[n].firstarc = p;}}void FindInDegree(ALGraph G, int indegree[]){int i;for (i = 1; i <= G.vexnum; i++){indegree[i] = 0;}for (i = 1; i <= G.vexnum; i++){while (G.vertices[i].firstarc){indegree[G.vertices[i].firstarc->adjvex]++;G.vertices[i].firstarc = G.vertices[i].firstarc->nextarc;}}}void TopologicalSort(ALGraph G){int indegree[M];int i, k, n,b,j=0;int a[20];int count = 0;ArcNode *p;SqStack S;FindInDegree(G, indegree);InitStack(&S);for ( i = 1; i <= G.vexnum; i++){if (!indegree[i])Push(&S,i);}while(!StackEmpty(&S)){Pop(&S,&n);a[j]=G.vertices[n].data;j++;count++;for (p = G.vertices[n].firstarc; p != NULL; p = p->nextarc) {k = p->adjvex;if (!(--indegree[k])){Push(&S,k);}}}printf("\n");if (count < G.vexnum){printf("该有向图有环\n");}else{printf("排序成功\n");printf("进行拓扑排序输出顺序为:"); for (b=0;b<j;b++){printf("%4d",a[b]);}printf("\n");}}int main(void){ALGraph G;CreatGraph(&G);TopologicalSort(G);system("pause");return 0;}。