精华内容
下载资源
问答
  • 拓扑排序算法思想

    2018-12-10 15:07:53
    拓扑排序算法思想和迪杰斯特拉算法思想,浅显易懂,附代码
  • PAGE 数据结构课程设计 设计说明书 有向图拓扑排序算法的实现 学生姓名 樊佳佳 学号 1318064017 班级 网络工程1301 成绩 指导教师 申静 数学与计算机科学学院 2016年1月4日 课程设计任务书 20152016学年第一学期 ...
  • 拓扑排序算法

    2021-05-26 02:30:37
    用C语言编写程序,实现图的拓扑排序操作的算法图的拓扑排序操作一、实验内容题目:实现下图的拓扑排序。5二、目的与要求(一)目的1、了解拓扑排序的方法及其在工程建设中的实际意义。2、掌握拓扑排序算法,了解拓扑...

    用C语言编写程序,实现图的拓扑排序操作的算法

    图的拓扑排序操作

    一、实验内容

    题目:实现下图的拓扑排序。

    1-119-jpg_6_0_______-191-0-0-191.jpg

    5

    二、目的与要求

    (一)目的

    1、了解拓扑排序的方法及其在工程建设中的实际意义。

    2、掌握拓扑排序的算法,了解拓扑排序的有向图的数据结构。

    (二)要求

    用C语言编写程序,实现图的拓扑排序操作。

    三、设计思想

    首先对有向图,我们采取邻接表作为数据结构。且将表头指针改为头结点, 其数据域存放该结点的入度,入度设为零的结点即没有前趋。

    在建立邻接表输入之前,表头向量的每个结点的初始状态为数据域VEX(入度)为零,指针域NXET为空,每输入一条弧< J, K > 建立链表的一个结点,同时令k 的入度加1,因此在输入结束时,表头的两个域分别表示顶点的入度和指向链表的第一个结点指针。

    在拓扑排序的过程之中,输入入度为零(即没有前趋)的顶点,同时将该顶点的直接后继的入度减1。

    (1)、查邻接表中入度为零的顶点,并进栈。

    (2)、当栈为空时,进行拓扑排序。

    (a)、退栈,输出栈顶元素V。

    (b)、在邻接表中查找Vj的直接后继Vk,将Vk的入度减一,并令入度减至零的顶点进栈。

    (3)、若栈空时输出的顶点数不是N个则说明有向回路,否则拓扑排序结束。为建立存放入度为零的顶点的栈,不需要另分配存储单元,即可借入入度为零的数据域。一方面,入度为零的顶点序号即为表头结点的序号,另一方面,借用入度为零的数据域存放带链栈的指针域(下一个入度的顶点号)。

    展开全文
  • 功能模块:拓扑排序 适用领域:有向图 基础模块:Graph Queue */ #include<stdlib.h> #include<stdio.h> #define MAXSIZE 50 typedef char VertexType; typedef struct EdgeNode {

    概念

    拓扑排序是对有向无圈图的顶点进行的一种排序,如若存在一条从V1至V2的路径,则V1排在V2前面
    

    问题

    对下图进行拓扑排序
    

    示例图

    在这里插入图片描述

    思想

    一般的拓扑排序算法
    1.找出0入度的顶点,将其入队
    2.出队,对该出队的顶点进行编码
    3.将该顶点及与之相连的边一同删除
    4.重复步骤1~3,直至队列为空
    5.输出拓扑编码
    

    输入流

    7 12
    A
    B
    C
    D
    E
    F
    G
    AB
    AC
    AD
    DC
    BD
    BE
    ED
    CF
    DF
    DG
    EG
    GF
    

    代码

    /*
        功能模块:拓扑排序
        适用领域:有向图
        基础模块:Graph Queue
    */
    #
    展开全文
  • 基于邻接表存储的图的拓扑排序算法,学习C++和理解数据结构很有帮助
  • 拓扑排序算法总结

    2019-10-26 15:15:21
    拓扑排序算法复习总结: 拓扑排序是图论中较为简单的一个算法,思路较为直接。 简单而言,由某个集合上的一个偏序得到该集合上的一个全序,这个操作称之为拓扑排序。(贴自百度百科) 拓扑排序思路: (1)找入度为0...

    拓扑排序算法复习总结:
    拓扑排序是图论中较为简单的一个算法,思路较为直接。
    简单而言,由某个集合上的一个偏序得到该集合上的一个全序,这个操作称之为拓扑排序。(贴自百度百科)

    拓扑排序思路
    (1)找入度为0的结点存入答案序列;
    (2)将与该结点相关的出边删除(相应的结点入度减1);
    重复上述过程至不存在入度为0的结点。

    拓扑排序一般用法
    (1)拓扑排序通常涉及图中结点的优先级关系,要由一系列结点之间的优先关系给出一个适合的优先级序列可采用拓扑排序进行。
    (2)判断有向图中是否存在环(也可采用dfs):利用拓扑排序算法进行至图中不存在入度为0的结点,而在一个环内所有结点的入度都不能为0,这样就可通过判断拓扑序列的长度是否为结点总数来判断是否存在环。

    输出拓扑序列:
    HDU1285:输出拓扑序列,要求字典序最小。
    如果不要求字典序最小,用任意一种数据结构来存储待得的元素均可,而这里要求字典序最小,故采用优先队列存储。

    #include<cstdio>
    #include<cstring>
    #include<algorithm>
    #include<queue>
    #include<vector> 
    using namespace std;
    #define maxn 30005
    priority_queue< int,vector<int>,greater<int> >q;
    vector<int>mp[maxn];
    vector<int>topo_ans;
    int in[maxn];
    
    void topo(int n)
    {
    	int i,j; 
    	for(i=1;i<=n;i++)
    	{
    		if(in[i]==0)
    		{
    			q.push(i);
    		}
    	}
    	while(!q.empty())
    	{
    		int now=q.top();
    		q.pop();
    		topo_ans.push_back(now); 
    		for(i=0;i<mp[now].size();i++)
    		{
    			in[mp[now][i]]--;
    			if(in[mp[now][i]]==0)
    			{
    				q.push(mp[now][i]);
    			}
    		}
    	}
    }
    
    int main()
    {
    	int i,j;
    	int n,m;
    	while(scanf("%d%d",&n,&m)!=EOF)
    	{
    		while(!q.empty()) q.pop();
    		for(i=0;i<=n;i++)
    		{
    			mp[i].clear();
    		}
    		topo_ans.clear();
    		memset(in,0,sizeof(in));
    		int x,y;
    		for(i=1;i<=m;i++)
    		{
    			scanf("%d%d",&x,&y);
    			mp[x].push_back(y);
    			in[y]++;
    		}
    		topo(n);
    		for(i=0;i<topo_ans.size();i++)
    		{
    			if(i==topo_ans.size()-1)
    			{
    				printf("%d\n",topo_ans[i]);
    			}
    			else
    			{
    				printf("%d ",topo_ans[i]);
    			}
    		}
    	}
    	return 0;
    } 
    

    判断有向图是否存在环
    HDU3342:说了一堆,意思就是判断是否有环。
    判断得到的拓扑序列长度是否等于结点总数即可。

    #include<cstdio>
    #include<cstring>
    #include<algorithm>
    #include<queue>
    #include<vector>
    using namespace std;
    #define maxn 150
    queue<int>q;
    vector<int>mp[maxn];
    int in[maxn];
    int len;
    
    void topo(int n)
    {
    	int i,j;
    	for(i=0;i<=n-1;i++)
    	{
    		if(in[i]==0)
    		{
    			q.push(i);
    		}
    	}
    	while(!q.empty())
    	{
    		int now=q.front();
    		q.pop();
    		len++;
    		for(i=0;i<mp[now].size();i++)
    		{
    			int x=mp[now][i];
    			in[x]--;
    			if(in[x]==0)
    			{
    				q.push(x);
    			}
    		}
    	}
    }
    
    inline void ini(int n)
    {
    	while(!q.empty())
    	{
    		q.pop();
    	}
    	for(int i=0;i<=n;i++)
    	{
    		mp[i].clear();
    		in[i]=0;
    	}
    	len=0;
     } 
    
    int main()
    {
    	int i,j;
    	int n,m;
    	while(scanf("%d%d",&n,&m)!=EOF)
    	{
    		if(n==0)
    		{
    			break;
    		}
    		ini(n);
    		int x,y; 
    		for(i=1;i<=m;i++)
    		{
    			scanf("%d%d",&x,&y);
    			mp[x].push_back(y);
    			in[y]++;
    		}
    		topo(n);
    		if(len!=n)
    		{
    			printf("NO\n");
    		}
    		else
    		{
    			printf("YES\n");
    		}
    	}
    	return 0;
     } 
    

    反向拓扑:
    HDU4587:要求1在前,1相同的基础上2在前,1.2相同的基础上3在前…这与字典序最小不一样了。假设有两条拓扑序列:6,3,1,4,5,2和2,4,5,6,1,3,这时前者字典序大于后者,但是前者才是答案。因为我们从序列头到尾获取字典序最小其实是每次贪心选择小的结点,但这样选择不一定是最优解,因为前面的结点编号小可能会导致没有先选择1这样的小结点所在的路径。这时采用逆向思维,反向建图,先输出结点序号大的,再逆序输出结果即可,因为这样相当于每次都先选择了最大的元素放在尾部,而放在尾部无后效性,故序号小的一定在前面。

    #include<cstdio>
    #include<cstring>
    #include<algorithm>
    #include<queue>
    #include<vector>
    using namespace std;
    #define maxn 30050
    priority_queue<int>q;
    vector<int>mp[maxn];
    vector<int>topo_ans;
    int in[maxn];
    
    void topo(int n)
    {
    	int i,j;
    	for(i=1;i<=n;i++)
    	{
    		if(in[i]==0)
    		{
    			q.push(i);
    		}
    	}
    	while(!q.empty())
    	{
    		int now=q.top();
    		q.pop();
    		topo_ans.push_back(now);
    		for(i=0;i<mp[now].size();i++)
    		{
    			int x=mp[now][i];
    			in[x]--;
    			if(in[x]==0)
    			{
    				q.push(x);
    			}
    		}
    	}
    }
    
    inline void ini(int n)
    {
    	while(!q.empty())
    	{
    		q.pop();
    	}
    	for(int i=0;i<=n;i++)
    	{
    		mp[i].clear();
    		in[i]=0;
    	}
    	topo_ans.clear();
    }
    
    int main()
    {
    	int i,j;
    	int n,m;
    	int t;
    	scanf("%d",&t);
    	while(t--)
    	{
    		scanf("%d%d",&n,&m);
    		ini(n);
    		int x,y;
    		for(i=1;i<=m;i++)
    		{
    			scanf("%d%d",&x,&y);
    			mp[y].push_back(x);
    			in[x]++;
    		}
    		topo(n);
    		for(i=topo_ans.size()-1;i>=0;i--)
    		{
    			if(i!=0)
    			{
    				printf("%d ",topo_ans[i]);
    			}
    			else
    			{
    				printf("%d\n",topo_ans[i]);
    			}
    		}
    	}
    	return 0;
    }
    
    展开全文
  • 拓扑排序算法思想:a.在有向图中任选一个没有前趋的顶点输出;b.从图中删除该顶点和所有以它为尾的弧;c.重复上述a、b,直到全部顶点都已输出,此时,顶点输出序列即为一个拓朴有序序列;或者直到图中没有无前趋的...
  • 这是我的拓扑排序算法:C++具体分析见注释,总体时间复杂度为O(n+e)#include "ALDGraph.h"#include "SqStack.h"#include #include using namespace std;//初始化inDegree[]数组,时间复杂度O(n+e)static void ...

    这是我的拓扑排序算法:C++

    具体分析见注释,总体时间复杂度为O(n+e)

    #include "ALDGraph.h"

    #include "SqStack.h"

    #include

    #include

    using namespace std;

    //初始化inDegree[]数组,时间复杂度O(n+e)

    static void findInDegree(ALDGraph G, int* inDegree)

    {

    for(int i = 0; i < G.vexNum; ++i)

    {

    ArcNode* p = G.vertexes[i].firstArc;

    while(p)

    {

    ++inDegree[p->adjVex];

    p = p->nextArc;

    }

    }

    }

    Status TopologicalSort(ALDGraph G)

    {

    int* inDegree = new int[G.vexNum];

    memset(inDegree, 0, sizeof(int)*G.vexNum);

    //ERROR:注意不是memset(inDegree, 0, 20);第三个参数是总的字节数,而不是初始化元素的个数。

    /*int inDegree[20];

    memset(inDegree, 0, sizeof(int) * 20);*/

    findInDegree(G, inDegree);

    SqStack S;

    InitStack_Sq(S);

    //将入度为0的顶点入栈,时间复杂度为O(n)

    for(int i = 0; i < G.vexNum; ++i)

    {

    if(0 == inDegree[i])

    {

    Push_Sq(S, i);

    }

    }

    int cnt = 0;

    bool first = true;

    cout << "拓扑排序开始----------------\n";

    cout << "拓扑排序之后的结果,如下:\n";

    //拓扑排序主体, 时间复杂度为O(n+e)

    while(!StackEmpty_Sq(S))

    {

    int i;

    Pop_Sq(S, i);

    if(first)

    {

    cout << G.vertexes[i].data;

    first = false;

    }

    else

    {

    cout << " -> " << G.vertexes[i].data;

    }

    ++cnt;

    for(ArcNode* p = G.vertexes[i].firstArc; p; p = p->nextArc)

    {

    int k = p->adjVex;

    if(0 == (--inDegree[k]))

    {

    Push_Sq(S, k);

    }

    }

    }

    cout << endl;

    cout << "拓扑排序结束----------------\n\n";

    if(cnt < G.vexNum)

    {

    cout << "此有向图中存在环路,拓扑排序出错" << endl;

    return ERROR;

    }

    else

    {

    return OK;

    }

    delete[] inDegree;

    }

    展开全文
  • 深度优先排序、广度优先排序和一种补充算法
  • 拓扑排序算法详讲

    2019-08-15 17:35:54
    经过一天的专研,终于明白了拓扑排序算法,写篇博客记录一下心得. 一.拓扑排序介绍 在一个表示工程的有向图中,用顶点表示活动,用弧表示活动之间的优先关系,这样的有向图为顶点表示活动的网,我们称为AOV网. 设G=(V,E)...
  • 拓扑排序,实际上是来解决一些有先后问题的图的算法,比如,我们引入的jar包会互相依赖,但是,这个依赖是有先后的。或者再换个例子,组装汽车时,必须有先后顺序的,有些零件就必须在其他装好之后再组装,拓扑排序...
  • 拓扑排序,就是对一个有向图构造拓扑序列的过程 构造拓扑排序时,是按照一种从最开始的逐个往后走的顺序输出 如上图所示。 如果输出的顶点是全部顶点,则是不存在环路的AOV网 如果输出顶点少了一个,则是存在回路的...
  • 数据结构——图——拓扑排序算法 对AOV网进行拓扑排序的基本思路是:从AOV网中选择一个入度为0的顶点输出,然后删去此顶点,并删除以此顶点为尾的弧,继续重复此步骤,直到输出全部顶点或者AOV 网中不存在入度为0的...
  • JavaScript的拓扑排序算法。 参见 。 :warning: 该代码要求定义regeneratorRuntime ,例如,通过导入 。 // Sort anything that can be iterated over with `for (const [u, v] of ...)` import { sorted } from...
  • 拓扑排序算法C++实现

    千次阅读 2018-01-04 19:18:44
    拓扑排序算法,基本思想: 1、从有向图中选取一个没有前驱(入度为0)的顶点,并输出之 2、从有向图中删去此顶点以及所有以它为尾的弧 3、重复上述两步,直至图空,或者图不空但找不到无前驱的顶点为止 数据...
  • 判断加入拓扑序列的顶点数和图的顶点数n是否相等,若相等则证明拓扑排序成功,和该图是有向无环图。 有向无环图:如果有向图的任意顶点都无法通过一些边回到自身,则这个图称为有向无环图 代码加注释 vector<int...
  • 转载自C++ 拓扑排序算法 有向无环图 如果一个有向图的任意顶点都无法通过一些有向边回到自身,那么称这个有向图为有向无环图。 不含环路的有向图必包含入度为零的顶点—因此一定存在拓扑排序 拓扑排序的应用 图...
  • 2019清华叉院夏令营某组笔试题第一题:图的拓扑排序算法(先得到不等式组然后转换为图的拓扑排序) 题目大意:n个人,编号1到n,给出m组数据,如0 1 2表示编号为1的人在编号为2的人出生前就死了;1 1 2表示存在一段...
  • 拓扑排序算法与深度优先搜索类似。不同的是,拓扑排序算法不会立即输出已访问的顶点,而是访问当前顶点邻接表中的所有相邻顶点,直到这个列表穷尽时,才将当前顶点压入栈中。拓扑排序算法被拆分为两个函数。第一个...
  • 拓扑排序:用下面的例子介绍------> ------------------------------------------------------------------------------------------------------------------------ 排序后的情况:即先取入度为0的顶点,反应到...
  • 什么是拓扑排序? 1、对一个有向无环图(Directed Acyclic Graph简称DAG)G进行拓扑排序,是将G中所有顶点排成一个线性序列,使得图中任意一对顶点u和v,若边(u,v)∈E(G),则u在线性序列中出现在v之前。通常,这样...
  • 拓扑排序算法分析(通俗易懂)

    万次阅读 多人点赞 2018-04-21 11:11:02
    拓扑排序(其实是一种依赖关系):对于有向且无环的图来说,当前这个节点的依赖来其之前已经完成了。下面附上一个图让大伙更好的理解:比如这个图:B需要依赖A才能完成,A需要依赖C和D才能完成,而D需要依赖F才能...
  • 拓扑排序 定义 拓扑排序(Topological Sort) :由某个集合上的一个偏序得到该集合上的一个全序的操作。 ◆ 集合上的关系:集合A上的关系是从A到A的关系 。 ◆ 关系的自反性:若 有(a,a)∈R,称集合A上的关系R...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 35,422
精华内容 14,168
关键字:

拓扑排序算法