图的拓扑排序

简述图之拓扑排序(python)实现 要想知道什么是拓扑排序,那首先得有数学功底嘛,所以我们先来说说离散数学中的偏序和全序的概念。 偏序: 集合内只有部分元素之间在这个关系下是可以比较的 比如:比如复数集中并不是所有的数都可以比较大小,那么“大小”就是复数集的一个偏序关系 全序: 集合内任何一对元素在在这个关系下都是相互可比较的 比如:有限长度的序列按字典序是全序的~(最常见的是单词在字典中是全序的) 当然我们来看看标准定义: 偏序的定义: 设R是集合A上的一个二元关系,若R满足: Ⅰ 自反性: 对任意x∈A,有xRx; Ⅱ 反对称性(即反对称 阅读详情

参考:https://wangkuiwu.github.io/2013/04/11/topsort-cplus

拓扑排序介绍

拓扑排序(Topological Order)是指,将一个有向无环图(Directed Acyclic Graph,简称 DAG)进行排序而得到一个有序的线性序列。

比如:有这样一种情景,一个项目包括 A、B、C、D 四个部分来完成,并且 A 依赖于 B 和 D,C 依赖于 D。现在要制定一个计划,写出 A、B、C、D 的执行顺序。这时候,就需要用到拓扑排序,他就是用来确定事物的发生顺序的。

在拓扑排序中,如果存在一条从顶点 A 到顶点 B 的路径,那么在排序结果中 B 必定出现在 A 的后面。

拓扑排序算法图解

拓扑排序的算法基本步骤:

1、构造一个队列 Q (queue) 和拓扑排序的结果队列 T (Topological)。

2、先把所有没有依赖顶点的节点放入 Q(也就是顶点没有入边)。

3、当 Q 中还有顶点的时候,执行下面的步骤:

3.1、从 Q 中取出一个顶点 n(将 n 从 Q 中删掉),并放入 T(将 n 加入到结果结合中)。

3.2、对 n 每一个邻接点 m(n 是起点,m 是终点)。

3.2.1、去掉边 <n, m>。

3.2.2、如果 m 没有依赖顶点,则把 m 放入 Q 中。

注:如果顶点 A 没有依赖顶点,指的是不存在以 A 为终点的边。

如下图:

图的拓扑排序-图1

图 G3

以上图 G3 为例,来进行拓扑排序的演示:

第一步:

图的拓扑排序-图2

结果 T:B -> C。

将 B 和 C 加入到排序结果中。顶点 B 和顶点 C 都是没有依赖顶点,因此将 B 和 C 加入到结果集 T 中。假设 A、B、C、D、E、F、G 按顺序存储,因此先访问B,再访问 C。

(1) 将 B 加入到排序结果中,然后去掉边 <B, A> 和 <B, D>;此时,由于 A 和 D 没有依赖顶点,因此并将 A 和 D 加入到队列 Q 中。

(2) 将 C 加入到排序结果中,然后去掉边 <C, F> 和<C, G>;此时,由于 F 有依赖顶点 D,G 有依赖顶点 A,因此不对 F 和 G 进行处理。

第二步:

图的拓扑排序-图3

结果 T:B -> C -> A -> D。

将 A、D 依次加入到排序结果中。第 1 步访问之后,A、D 都是没有依赖顶点的,根据存储顺序,先访问 A,然后访问 D。访问之后,删除顶点 A 和顶点 D 的出边。

第三步:

图的拓扑排序-图4

结果 T:B -> C -> A -> D -> G -> E -> F。

因为上一步操作后,使得 G、E、F 没有依赖点,所以将 G、E、F 放入排序结果 T 中即可,因为这三个点已经没有出边。

拓扑排序代码实现

拓扑排序是对有向图的排序,使用图的邻接表的表示方法实现比较清晰简单,下面以邻接表的形式进行实现。

此代码实现基于之前的:有向图的邻接矩阵与邻接表详细实现。

#include <iostream>
#include <queue>
using namespace std;

#define MAX 100

class ListDG
{
private:
    struct ENode //每一条边
    {
        int iVex;               //指向的顶点的位置
        ENode *nextEdge = NULL; //指向顶点的下一条边的指针
    };
    struct VNode //数组中存储的顶点
    {
        char data;
        ENode *firstEdge = NULL; //指向第一条该顶点的边
    };

private:
    int mVexNum;      //图的顶点数目
    int mEdgeNum;     //图的边的数目
    VNode mVexs[MAX]; //存储顶点
public:
    ListDG();
    ListDG(char vexs[], int vNum, char edges[][2], int eNum);
    ~ListDG();
    //打印邻接表
    void print();
    //图的拓扑排序
    int TopologicalSort();

private:
    //读取一个合法的输入字符
    char readChar();
    //返回字符ch在的位置
    int getPosition(char ch);
    //将node结点链接到list的最后
    void linkLast(ENode *list, ENode *node);
};

ListDG::ListDG()
{
    char c1, c2;
    int p1, p2;
    ENode *node1;
    cout << "输入顶点数:";
    cin >> mVexNum;
    cout << "输入边数:";
    cin >> mEdgeNum;
    if (mVexNum > MAX || mEdgeNum > MAX || mVexNum < 1 || mEdgeNum < 1 || (mEdgeNum > (mVexNum * (mVexNum - 1))))
    {
        cout << "输入有误!" << endl;
        return;
    }
    for (int i = 0; i < mVexNum; ++i)
    {
        cout << "vertex(" << i << "):";
        mVexs[i].data = readChar();
    }
    //初始化邻接表的边
    for (int j = 0; j < mEdgeNum; ++j)
    {
        cout << "edge(" << j << "):";
        c1 = readChar();
        c2 = readChar();
        p1 = getPosition(c1);
        p2 = getPosition(c2);
        if (p1 == -1 || p2 == -1)
        {
            cout << "输入的边有错误!" << endl;
            return;
        }

        node1 = new ENode();
        node1->iVex = p2;
        if (mVexs[p1].firstEdge == NULL)
            mVexs[p1].firstEdge = node1;
        else
            linkLast(mVexs[p1].firstEdge, node1);
    }
}

ListDG::ListDG(char *vexs, int vNum, char (*edges)[2], int eNum)
{
    if (vNum > MAX || eNum > MAX)
        return;
    char c1, c2;
    int p1, p2;
    ENode *node1;
    mVexNum = vNum;
    mEdgeNum = eNum;
    for (int i = 0; i < mVexNum; ++i)
    {
        mVexs[i].data = vexs[i];
    }
    for (int j = 0; j < mEdgeNum; ++j)
    {
        c1 = edges[j][0];
        c2 = edges[j][1];
        p1 = getPosition(c1);
        p2 = getPosition(c2);
        if (p1 == -1 || p2 == -1)
        {
            cout << "输入的边有错误!" << endl;
            return;
        }
        node1 = new ENode();
        node1->iVex = p2;
        if (mVexs[p1].firstEdge == NULL)
            mVexs[p1].firstEdge = node1;
        else
            linkLast(mVexs[p1].firstEdge, node1);
    }
}

ListDG::~ListDG() {}

void ListDG::linkLast(ENode *list, ENode *node)
{
    ENode *p = list;
    while (p->nextEdge)
        p = p->nextEdge;
    p->nextEdge = node;
}

int ListDG::getPosition(char ch)
{
    for (int i = 0; i < mVexNum; ++i)
    {
        if (mVexs[i].data == ch)
            return i;
    }
    return -1;
}

char ListDG::readChar()
{
    char ch;
    do
    {
        cin >> ch;
    } while (!((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')));
    return ch;
}

int ListDG::TopologicalSort()
{
    int i, j;
    std::queue<int> queue;          //辅助队列
    int *ins = new int[mVexNum];    //入度数组
    char *tops = new char[mVexNum]; //拓扑排序结果
    int top_index = 0;
    ENode *node;
    //先统计每个顶点的入度
    for (i = 0; i < mVexNum; ++i)
    {
        node = mVexs[i].firstEdge;
        while (node != NULL)
        {
            ins[node->iVex]++;
            node = node->nextEdge;
        }
    }
    //将所有入度为0的顶点入队列
    for (i = 0; i < mVexNum; ++i)
    {
        if (ins[i] == 0)
        {
            queue.push(i); //入队列
        }
    }
    while (!queue.empty())
    {
        //出队列
        j = queue.front();
        queue.pop();
        tops[top_index++] = mVexs[j].data; //将该顶点添加到tops中,tops是排序结果
        node = mVexs[j].firstEdge;         //获得以该顶点为起点的出边的队列
        //将与该node关联的节点的入度减1,若减1之后,该节点的入度为0,则将该节点添加到队列中。
        while (node != NULL)
        {
            ins[node->iVex]--;
            //若该节点的入度为0,将其入队列
            if (ins[node->iVex] == 0)
            {
                queue.push(node->iVex);
            }
            node = node->nextEdge;
        }
    }
    if (top_index != mVexNum) //拓扑排序失败
    {
        cout << "该图中有回路,拓扑排序失败" << endl;
        delete[] ins;
        delete[] tops;
        return 1;
    }
    //拓扑排序成功,打印结果
    cout << "TopSort:";
    for (i = 0; i < mVexNum; ++i)
    {
        cout << tops[i] << " ";
    }
    cout << endl;
    delete[] ins;
    delete[] tops;
    return 0;
}

void ListDG::print()
{
    ENode *node;
    for (int i = 0; i < mVexNum; ++i)
    {
        cout << i << "(" << mVexs[i].data << "):";
        node = mVexs[i].firstEdge;
        while (node != NULL)
        {
            cout << node->iVex << "(" << mVexs[node->iVex].data << ")";
            node = node->nextEdge;
        }
        cout << endl;
    }
}

int main(int argc, char **argv)
{
    char vexs[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
    char edges[][2] = {
        {'A', 'G'},
        {'B', 'A'},
        {'B', 'D'},
        {'C', 'F'},
        {'C', 'G'},
        {'D', 'E'},
        {'D', 'F'}};
    int vNum = sizeof(vexs) / sizeof(vexs[0]);
    int eNum = sizeof(edges) / sizeof(edges[0]);
    //1. 根据提供的数据生成
    ListDG ldg(vexs, vNum, edges, eNum);
    ldg.print();
    ldg.TopologicalSort();
    //2. 手动生成
    // ListDG ldg1;
    // ldg1.print();
    return 0;
}

程序运行结果如下:

$ ./test
0(A):6(G)
1(B):0(A)3(D)
2(C):5(F)6(G)
3(D):4(E)5(F)
4(E):
5(F):
6(G):
TopSort:B C A D G E F 
Java实现图的拓扑排序 拓扑排序是一种对有向无环图(DAG)进行排序的算法,它可以将图中的节点按照依赖关系进行排序,使得所有的依赖关系都能够得到满足。在拓扑排序中,如果存在一条从节点 A 到节点 B 的有向路径,那么节点 A 必须排在节点 B 的前面。来存储入度为0的节点,并将其依次出队,将其邻接节点的入度减1。最后,如果拓扑排序的结果长度不等于图的顶点数,说明图中存在环,无法进行拓扑排序。方法中,我们创建了一个有向无环图,并添加了一些边。在上面的代码中,我们首先创建了一个名为。方法进行拓扑排序,并输出排序结果。 阅读详情

相关推荐

C/C++ 图的拓扑排序算法详解及源码

图的拓扑排序算法是一种用于有向无环图(DAG)的排序算法,它根据图中各顶点之间的依赖关系,将图中所有顶点线性排序。拓扑排序的结果是一个顶点的线性排序,使得对于任意的有向边(u,v),顶点u在排序中都在顶点v之前。图的拓扑排序算法的优点是能够有效地解决有向无环图中各顶点之间的依赖关系问题,适用于任务调度、编译器的依赖分析等场景。其时间复杂度为O(V+E),其中V为顶点数,E为边数。图的拓扑排序算法的缺点是要求图是有向无环图,若出现环路则无法进行拓扑排序。此外,拓扑排序不是唯一的,可能存在多个合法的排序结果。

希望我的博客,能帮上你解决学习中工作中所遇到的问题 7456

图结构专栏——拓扑排序

三种方法实现拓扑排序 一、什么是拓扑排序 在图论中,拓扑排序(Topological Sorting)是一个有向无环图(DAG, Directed Acyclic Graph)的所有顶点的线性序列。且该序列必须满足下面两个条件: 每个顶点出现且只出现一次。 若存在一条从顶点 A 到顶点 B 的路径,那么在序列中顶点 A 出现在顶点 B 的前面。 有向无环图(DAG)才有拓扑排序,非DAG图没有拓扑排序一说。 例如,下面这个图: 它是一个 DAG 图,那么如何写出它的拓扑排序呢?这里说一种比较常用的方法

lizefeng1998的博客 9023

第5-2课:图的拓扑排序

拓扑排序常用来确定一个依赖关系集中、事物发生的顺序。一个典型的应用场景就是在项目管理或工程实施中安排各种生产活动的计划,在考虑各种活动的依赖关系的基础上,安排各种活动的开始时间,使得项目或工程能够以高效合理的速度完成。这些功能通常需要在基本的拓扑排序算法基础上进行适当的改造,本课仿照的项目管理软件功能实现的“根据活动开始时间排序”算法,就是一种这样的改造。图的拓扑排序涉及的概念有:有向无环图...

oRbIt 的专栏 703

【数据结构基础】图 - 拓扑排序(Topological sort)

对于任何有向图而言,其拓扑排序为其所有结点的一个线性排序(对于同一个有向图而言可能存在多个这样的结点排序)。该排序满足这样的条件——对于图中的任意两个结点u和v,若存在一条有向边从u指向v,则在拓扑排序中u一定出现在v前面。例如一个有向无环图如下:结点1必须在结点2、3之前结点2必须在结点3、4之前结点3必须在结点4、5之前结点4必须在结点5之前则一个满足条件的拓扑排序为[1, 2, 3, 4, 5]。

DeveloperFire的博客 2685

关于三维全波电磁场仿真软件CST的安装和问题解决

百度网盘链接:https://pan.baidu.com/s/1RgWr8Qau1EzSOlh29SewFQ提取码:fzza这里是2023版本的CST,需要其他版本的uu们可以去官网或者其他人的网盘下载。

weixin_60728441的博客 3624

探索Vortex开源GPGPU:RISC-V SIMT架构(4-1),Execute SFU(1)

本文详细分析了Vortex RISC-V内核6级流水线中Execute阶段的SFU(特殊功能单元)模块。重点介绍了SFU的数据流结构,包含dispatch_unit、pe_switch、csr_unit、wctl_unit和gather_unit五个子模块。文章深入解析了warp控制指令wspawn和tmc的实现机制:wspawn用于激活指定数量的warp并设置新PC值,tmc则用于控制线程掩码和warp状态。通过C代码和汇编指令的对照分析,阐明了这些指令在并行计算中的关键作用,包括线程激活、状态切换和执行

weixin_55313207的博客 1364

【图论】拓扑排序:一个名字高大上的实际很简单的算法(图文详解)

前言 在看到“拓扑序列”这4个字的时候,笔者人是傻的。拓扑序列是啥?听着就感觉好厉害!然后,当我得知“拓扑”两个字其实是一个大家都知道的单词“Top”的音译时,我不禁在想:翻译成这样,估计是故意让大家觉得这个知识点很难的吧。事实证明的确是这样,拓扑排序的概念与实现都是非常简单的。别被看上去高大上的名字吓到了。 拓扑序列概念介绍 首先,我们给出一个如图的有向图 然后我们给出一个序列a={1,2,3,4},我们随便在有向图中选择一条边,我们都能满足在序列a中,这条边起点的编号一定在终点的编号之前。那么,我们就

qq_49688477的博客 5287

【Python程序开发】湖南省职业院校技能大赛python程序开发赛项样题二

【Python程序开发】湖南省职业院校技能大赛python程序开发赛项样题二

况老师话竞赛&blog 2206

什么是拓扑排序

什么是拓扑排序 拓扑排序(Topological Order),很多人听说过,但是不了解的一种算法。或许很多人只知道它是图论的一种排序,至于干什么的不清楚。又或许很多人可能还会认为它是一种啥排序。 而实质上它只是将DAG图的顶点排成一个线性序列,得到一个顶点的全序集合。其排序的顺序依据就是节点的指向关系。比如前言的DAG图: … 节点5在节点4和节点3的后面 节点9在节点6和节点7的后面 … 那么最后得到的节点的线性序列结果,也一定要满足上面的指向顺序。 每一个节点都拥有入度(有多少点导向它,也就是开.

qq_42013584的博客 1704

PPO(Proximal Policy Optimization)算法原理及实现,详解近端策略优化

接着上面的讲,PG方法一个很大的缺点就是参数更新慢,因为我们每更新一次参数都需要进行重新的采样,这其实是中on-policy的策略,即我们想要训练的agent和与环境进行交互的agent是同一个agent;与之对应的就是off-policy的策略,即想要训练的agent和与环境进行交互的agent不是同一个agent,简单来说,就是拿别人的经验来训练自己。举个下棋的例子,如果你是通过自己下棋来不断提升自己的棋艺,那么就是on-policy的,如果是通过看别人下棋来提升自己,那么就是off-policy的。

weixin_41106546的博客 9万+

1 初识智能化测试

非常感谢您可以和我一起来聊一聊智能化测试的一些事。智能化测试是一个新鲜又老旧的问题,说新鲜是因为很多人当听到智能化测试都会联想到人工智能、机器学习、深度学习等高大上的技术,很多时候觉得离我们的实际工作还很远;说老旧,是因为智能化测试的一些技术的发展在行业里面已经很久了,例如符号执行、静态分析等技术已经有很长的历史了。近些年,随着测试技术的的飞速发展,智能化测试也有了越来越多的实践,优秀的开源项目慢慢的被行业推行并且落地。那么在这里我们就一起来聊聊智能化测试以及智能化测试好的思路、实践、方法以及技术落地过程。

Criss@陈磊 2626

图的拓扑排序的算法实现,C语言,栈,超详细版本

数据结构课程设计 设计说明书 图的拓扑排序的算法实现 设计内容: 拓扑排序在工程管理领域中的应用广泛,可用于判断工程能否顺利开展,即判断有向图中是否存在回路。对于一个有向图,先由键盘输入其顶点和弧的信息,采用恰当存储结构保存该有向图后,依据拓扑排序算法思想输出其相应的顶点拓扑有序序列,并提示用户是否存在回路。 设计要求: 1)问题分析和任务定义:根据设计题目的要求,充分地分析和理解问题...

qq_44236958的博客 4273

人工智能训练师三级考试大纲深度解读|理论+实操分值分布+六大模块占比

三级人工智能训练师考试分为理论和实操两大模块(各100分,合格线60分)。理论考试包含AI基础(30%)、数据标注(25%)、模型训练(20%)、测试(15%)和系统运维(10%),题型为客观题;实操考核侧重数据标注(40%)、模型测试(35%)和系统运维(25%),采用现场操作形式。复习应优先关注AI基础和数据标注等高分值模块,实操需重点掌握标准流程和结果准确性(占评分70%)。考试要求两模块均达标,理论侧重概念理解,实操强调规范执行与文档完整。

白话机器学习 1109

图的拓扑排序算法研究与应用

在图论算法领域,图的拓扑排序是一项具有重要理论意义与广泛实际应用价值的操作。本文深入剖析图的拓扑排序问题,通过详细的问题定义,全面阐释基于 Kahn 算法和深度优先搜索(DFS)的拓扑排序实现思路,给出清晰易懂的代码实现,并对算法的时间复杂度和空间复杂度进行精确分析。此外,还深入探讨这些算法在实际场景中的应用,为解决涉及图结构的任务调度、依赖关系处理等问题提供有效的方法和思路。

cloudman08的博客 1077

对CryptoDriver里密钥格式定义的探索(1)

一入网络安全才发现深似海,传统汽车MCU码农转型之路异常艰难。在CP AUTOSAR中的CryptoDriver SWS对密钥格式的需求来源于RFC,其中要求了RSA、ECC、SHE等key material的格式。再往下看,我就有些迷糊了,例如关于RSA Private Key的OCTEE STRING格式根据IETF RFC8017,Public Key又得根据RFC5280,完全不得其解。所以今天先从生成密钥对,并对其进行解析开始,一步一步拆解。

认真搞搞汽车MCU 531

UE5、CesiumForUnreal实现加载GeoJson绘制多面(MultiPolygon)功能(支持点选高亮)

UE5、CesiumForUnreal实现加载GeoJson实现多面(MultiPolygon)的绘制功能,并且支持点选高亮和属性查询。

专注GIS开发 4629

图的拓扑排序:图的BFS的应用题

1)图的算法其实很简单,但是要造一个统一的图数据结构,很难,你要熟悉的是图的统一构造法:丰富的图结构数据 2)图的拓扑排序,给你的是图,要找入度为0的点,也需要记录每个点的入度,用队列中那些入度为0的点,消除他们对直接邻居的影响,逻辑上删除cur,实际上就是然让邻居的入度--。依次打印即可。 3)笔试求AC,可以不考虑空间复杂度,但是面试既要考虑时间复杂度最优,也要考虑空间复杂度最优。

weixin_46838716的博客 494

怀旧版电脑GBC模拟器

再现原版GBC掌机的界面,电脑运行连游戏界面都一样大小,很怀旧,很真实,(英文版)强烈推荐,很小的文件,很难才找到的。

图的拓扑排序算法C++代码

2019清华叉院夏令营某组笔试题第一题:图的拓扑排序算法(先得到不等式组然后转换为图的拓扑排序) 题目大意:n个人,编号1到n,给出m组数据,如0 1 2表示编号为1的人在编号为2的人出生前就死了;1 1 2表示存在一段时间,1和2两个人同时活着。现在要求给出一组能满足上述m组数据的n个人出生死亡日期,不存在这样的日期就返回"NO"。 #include <iostream> #incl...

宫·商的博客 615

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

IDEA的使用指南

IDEA基于java的使用手册,可以最快速的上手,在使用中不断的丰富自己的使用技巧.

图论算法—图的拓扑排序介绍和Kahn算法原理解析以及Java代码的实现

介绍了图的拓扑排序的概念以及求拓扑序列的算法:Kahn算法的原理,最后提供了基于邻接矩阵和邻接表的图对该算法的Java实现。

终生学习践行者 4464

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

数据结构24————图的拓扑排序和关键排序

数据结构21————图的拓扑排序和关键排序 一. 目录 数据结构21图的拓扑排序和关键排序 一 目录 二 图的拓扑排序 算法定义 算法思路 算法演示 算法代码 三 图的关键路径 算法定义 算法思路 算法演示 算法代码 修改后拓扑排序 关键路径算法 四 源码地址 五 参考资料 二. 图的拓扑排序 1. 算法定义 AOV网 在一个表示工程

冰炭不投day的博客 1688

用C语言编程实现拓扑排序,实现图的拓扑排序

已结贴√问题点数:20回复次数:6 实现图的拓扑排序#include "stdlib.h"#include "stdio.h"#include "string.h"/*******************************************//*以下为链式队列操作*//**********************************...

weixin_36179103的博客 1251
上一篇: 图的遍历之DFS与BFS
下一篇: 图的最小生成树之Prim算法
code_peak
博客等级 码龄5年 403粉丝 67原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值