图之有向无环图的应用--拓扑排序算法的实现

最新推荐文章于 2022-08-03 11:43:44 发布
最新推荐文章于 2022-08-03 11:43:44 发布
阅读量1k 收藏
点赞数 1
分类专栏： //【数据结构/算法】 图 算法 文章标签： 图 拓扑排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/derkampf/article/details/57415605
版权

前面博文对拓扑排序进行了引入
http://blog.csdn.net/derkampf/article/details/57414185，这一篇进行拓扑排序算法的实现。
一.概念
由偏序得到全序的操作称为拓扑排序。在拓扑排序之后，有向图中的每一个顶点都会按照一定的次序进行输出。
二.如何进行拓扑排序
步骤：
1.在有向图中选择一个无前驱顶点（无入度）且输出
2.删除该顶点以及所有以该顶点作为起始顶点的边。
重复1,2操作，最终直至全部顶点全部输出。若最终已经没有无入度的顶点，且有向图中还有顶点，说明AOV-网中有环（这也是拓扑排序的关键）
这里写图片描述
三.拓扑排序算法的实现
以下图为例，进行实现
这里写图片描述
1.对之前编写的邻接表代码进行改动，由于之前针对的是无向图，现在是有向图，所以需要更改的有：(1)插入边，(2)删除边，(3)删除顶点
(1)单向插入边

template<class Type>
bool GraphLink<Type>::InsertEdge(const Type &vertex1, const Type &vertex2)
{
    int v1 = GetPosVertex(vertex1);
    int v2 = GetPosVertex(vertex2);
    if(v1 == -1 || v2 == -1)
        return false;
    //采用单链表的头插方式
    //v1-->v2
    Edge<Type> *e = new Edge<Type>(v2);
    e->link = NodeTable[v1].adj;
    NodeTable[v1].adj = e;
    numEdges++;
}

(2)单向删除边

template<class Type>
bool GraphLink<Type>::RemoveEdge(const Type &vertex1, const Type &vertex2)
{
    int v1 = GetPosVertex(vertex1);
    int v2 = GetPosVertex(vertex2);
    if(v1 == -1 || v2 == -1)
        return false;
    //删除v1-->v2
    Edge<Type> *p = NodeTable[v1].adj;
    Edge<Type> *q = NULL;
    while(p != NULL && p->dest != v2)
    {
        q = p;
        p = p->link;
    }
    if(NULL == p)
        return false;
    if(q == NULL)//说明删除的是头结点
        NodeTable[v1].adj = p->link;
    else
        q->link = p->link;
    delete p;
    p == NULL;
    numEdges--;
}

(3)删除顶点vertex时，遍历NodeTable，删除所有包含v的边，之后最后一个顶点替换vertex时，将所有边链表上包含的最后一个顶点下标替换成vertex的下标

template<class Type>
bool GraphLink<Type>::RemoveVertex(const Type &vertex)
{
    /*思路：
    **  1.剔除顶点vertex边链表中所包含顶点中的关于vertex的结点(可以借用RemoveEdage())
    **  2.删除所有包含该顶点的边。
    **  3.最后一行覆盖所删除行
    （1）顶点覆盖顶点
    1）p保存最后一行的单链表，删除行的顶点指向最后一行的边链表，tmp保存numVertices-1   
    2）覆盖顶点    
    3）与最后一行所关联的结点，将他们所包含的最后一个结点的下标更改成所删除的下标
    (2)边链表覆盖边链表（指向tmp）
    **  4.减少顶点数
    */   
    int v = GetPosVertex(vertex);
    if(v == -1)
        return false;
    //1.
    Edge<Type> *p = NodeTable[v].adj;
    while(p != NULL)
    {
        RemoveEdge(vertex, NodeTable[p->dest].data);
        p = NodeTable[v].adj;
    }
    //2.
    int num = numVertices-1;
    while(num >= 0)
    {
        p = NodeTable[num].adj;
        if(NULL != p && p->dest != v)
            p = p->link;
        if(NULL != p && p->dest == v)
            RemoveEdge(NodeTable[num].data, NodeTable[v].data);
        num--;
    }
    //3.
    //1)
    p = NodeTable[numVertices-1].adj;
    NodeTable[v].adj = p;
    int tmp = numVertices-1;
    //2)
    NodeTable[v].data = NodeTable[numVertices-1].data;
    //3)
    num = numVertices - 2;
    while(num >= 0)
    {
        p = NodeTable[num].adj;
        if(NULL != p && p->dest != tmp)
            p = p->link;
        if(NULL != p && p->dest == tmp)
            p->dest = v;
        num--;
    }
    //4.
    numVertices--;
    return true;
}

2.进行拓扑排序
为了找到入度为0的顶点，我们需要借助一个数组模拟栈结构，步骤如下：
(1)建立一个count数组用来保存每个顶点的入度 ，top==-1,先全部初始化为0，然后根据邻接表将入度填充在数组中；
(2)当遇到入度为0的顶点（下标i）时，count[i] = top;top = i; 用来模拟入栈；
(3)将所有入度为0的点入栈完毕后，在这里如果一开始有向图就是一个闭环，则top依然为-1，这也是输出“有向图有环”的依据。
(4)进行打印”入度为0的顶点”的操作。即模拟出栈的操作v=top;top=count[top],然后打印下标为v的顶点，此时top回退到上一个入度为0的顶点（即模拟的栈顶）。
(5)进行模拟出栈操作后，将以出栈元素v为起始点的顶点元素(即第一个邻接顶点)的入度进行-1操作，如果-1之后入度为0，则该元素为新的栈顶元素，寻找下一个邻接顶点重复上述动作直至到达边链表的尾部
(6)如果有向图中有环，那么在进行(4)(5)时，top的值从未改变，那么会一直回退到top==-1的状态，即在循环时，到达(3)的操作，会输出”有环”,退出程序。
下面是具体实现

bool GraphLink<Type>::TopologicalSort()
{
   //(1)
   int top = -1;
   Edge<Type> *p;
   for(int i=0; i<numVertices; ++i)
   {
       p = NodeTable[i].adj;
       while(NULL != p)
       {
           count[p->dest]++;
           p = p->link;
       }
   }
   //(2)
   for(int i=0; i<numVertices; ++i)
   {
        if(count[i] == 0)
        {
            count[i] = top;
            top = i;
        }
   }
   int v,w;
   for(int i=0; i<numVertices; ++i)
   {
       //(3)
        if(top == -1)
        {
            cout<<"无向图有环"<<endl;
            return false;
        }
        //(4)
        v = top;
        top = count[top];
        cout<<NodeTable[v].data<<"-->";
        w = GetFirstNeighbor(NodeTable[v].data);
        while(w != -1)
        {
            //(5)
            if(--count[w] == 0)
            {
                count[w] = top;
                top = w;
            }
            w = GetNextNeighbor(NodeTable[v].data, NodeTable[w].data);
        }
   }
   cout<<"over."<<endl;
   return true;
}

源码展示：

/*图之拓扑排序算法实现
**GraphLink.h
**2016.2.20
*/
#pragma once

#include<iostream>
using namespace std;

#define DEFAULT_VERTEX_SIZE 10
template<class Type> class GraphLink;
template<class Type>
class Edge
{
    friend class GraphLink<Type>;
public:
    Edge(int num = -1) : dest(num),link(NULL)
    {}
    ~Edge()
    {}
private:
    int dest;
    Edge *link;
};
template<class Type>
class Vertex
{
    friend class GraphLink<Type>;
public:
    Vertex():data(),adj(NULL)
    {}
    ~Vertex()
    {}
private:
    Type data;
    Edge<Type> *adj;
};
template<class Type>
class GraphLink
{
public:
    GraphLink(int sz = DEFAULT_VERTEX_SIZE)
    {
        maxVertices = sz > DEFAULT_VERTEX_SIZE ? sz : DEFAULT_VERTEX_SIZE;
        numEdges = numVertices = 0;
        NodeTable = new Vertex<Type>[maxVertices];
        count = new int[maxVertices];
        for(int i=0; i<maxVertices; ++i)
            count[i] = 0;
    }
    ~GraphLink()
    {
        int n = numVertices;
        for(int i = 0; i < n; ++i)
            RemoveVertex(NodeTable[i].data);
        delete []NodeTable;
        delete []count;
    }
public:
    bool InsertVertex(const Type &v);               //插入顶点v
    bool InsertEdge(const Type &vertex1, const Type &vertex2);//插入vertex1-->vertex2边
    int NumberOfVertice()const;                     //获取顶点总数
    int NumberOfEdge()const;                        //获取边总数
    int GetFirstNeighbor(const Type &vertex)const;  //获取vertex的第一个邻接顶点
    int GetNextNeighbor(const Type &vertex1, const Type &vertex2)const;//获取vertex1的邻接顶点vertex2的下一个邻接顶点
    bool RemoveVertex(const Type &vertex);          //删除顶点vertex
    bool RemoveEdge(const Type &vertex1, const Type &vertex2);//删除vertex1和vertex2构成的边
    bool TopologicalSort();
public:
    void ShowGraph()const
    {
        for (int i = 0; i < numVertices; ++i)
        {
            cout<<NodeTable[i].data<<"-->";
            Edge<Type> *e = NodeTable[i].adj;
            while(e != NULL)
            {
                cout<<e->dest<<"-->";
                e = e->link;
            }
            cout<<"Nul"<<endl;
        }
    }
private:
    int GetPosVertex(const Type v)const
    {
        for (int i = 0; i < numVertices; ++i)
        {
            if(NodeTable[i].data == v)
                return i;
        }
        return -1;
    }

    Vertex<Type> *NodeTable;//顶点表
    int maxVertices;
    int numVertices;
    int numEdges;
    int *count; 
};
template<class Type>
bool GraphLink<Type>::InsertVertex(const Type &v)
{
    if(numVertices > maxVertices)
        return false;
    NodeTable[numVertices++].data = v;
    return true;
}
template<class Type>
bool GraphLink<Type>::InsertEdge(const Type &vertex1, const Type &vertex2)
{
    int v1 = GetPosVertex(vertex1);
    int v2 = GetPosVertex(vertex2);
    if(v1 == -1 || v2 == -1)
        return false;
    //采用单链表的头插方式
    //v1-->v2
    Edge<Type> *e = new Edge<Type>(v2);
    e->link = NodeTable[v1].adj;
    NodeTable[v1].adj = e;
    numEdges++;
}
template<class Type>
int GraphLink<Type>::NumberOfVertice()const
{return numVertices;}
template<class Type>
int GraphLink<Type>::NumberOfEdge()const
{return numEdges;}
template<class Type>
int GraphLink<Type>::GetFirstNeighbor(const Type &vertex)const
{
    int v = GetPosVertex(vertex);
    if(v == -1)
        return -1;
    if(NodeTable[v].adj != NULL)
        return NodeTable[v].adj->dest;
    return -1;
}
template<class Type>
int GraphLink<Type>::GetNextNeighbor(const Type &vertex1, const Type &vertex2)const
{
    int v1 = GetPosVertex(vertex1);
    int v2 = GetPosVertex(vertex2);
    if(v1 == -1 || v2 == -1)
        return -1;
    Edge<Type> *p = NodeTable[v1].adj;
    while(p != NULL && p->dest != v2)
        p = p->link;
    if(NULL == p)
        return -1;
    if(p->link != NULL)
        return p->link->dest;
    return -1;
}
template<class Type>
bool GraphLink<Type>::RemoveEdge(const Type &vertex1, const Type &vertex2)
{
    int v1 = GetPosVertex(vertex1);
    int v2 = GetPosVertex(vertex2);
    if(v1 == -1 || v2 == -1)
        return false;
    //删除v1-->v2
    Edge<Type> *p = NodeTable[v1].adj;
    Edge<Type> *q = NULL;
    while(p != NULL && p->dest != v2)
    {
        q = p;
        p = p->link;
    }
    if(NULL == p)
        return false;
    if(q == NULL)//说明删除的是头结点
        NodeTable[v1].adj = p->link;
    else
        q->link = p->link;
    delete p;
    p == NULL;
    numEdges--;
}
template<class Type>
bool GraphLink<Type>::RemoveVertex(const Type &vertex)
{
    /*思路：
    **  1.剔除顶点vertex边链表中所包含顶点中的关于vertex的结点(可以借用RemoveEdage())
    **  2.删除所有包含该顶点的边。
    **  3.最后一行覆盖所删除行
    （1）顶点覆盖顶点
    1）p保存最后一行的单链表，删除行的顶点指向最后一行的边链表，tmp保存numVertices-1   
    2）覆盖顶点    
    3）与最后一行所关联的结点，将他们所包含的最后一个结点的下标更改成所删除的下标
    (2)边链表覆盖边链表（指向tmp）
    **  4.减少顶点数
    */   
    int v = GetPosVertex(vertex);
    if(v == -1)
        return false;
    //1.
    Edge<Type> *p = NodeTable[v].adj;
    while(p != NULL)
    {
        RemoveEdge(vertex, NodeTable[p->dest].data);
        p = NodeTable[v].adj;
    }
    //2.
    int num = numVertices-1;
    while(num >= 0)
    {
        p = NodeTable[num].adj;
        if(NULL != p && p->dest != v)
            p = p->link;
        if(NULL != p && p->dest == v)
            RemoveEdge(NodeTable[num].data, NodeTable[v].data);
        num--;
    }
    //3.
    //1)
    p = NodeTable[numVertices-1].adj;
    NodeTable[v].adj = p;
    int tmp = numVertices-1;
    //2)
    NodeTable[v].data = NodeTable[numVertices-1].data;
    //3)
    num = numVertices - 2;
    while(num >= 0)
    {
        p = NodeTable[num].adj;
        if(NULL != p && p->dest != tmp)
            p = p->link;
        if(NULL != p && p->dest == tmp)
            p->dest = v;
        num--;
    }
    //4.
    numVertices--;
    return true;
}
template<class Type>
bool GraphLink<Type>::TopologicalSort()
{
//(1)建立一个count数组用来保存每个顶点的入度 ，top==-1,先全部初始化为0，然后根据邻接表将入度填充在数组中；
//(2)当遇到入度为0的顶点（下标i）时，`count[i] = top;top = i;` 用来模拟入栈；
//(3)将所有入度为0的点入栈完毕后，在这里如果一开始有向图就是一个闭环，则top依然为-1，这也是输出“有向图有环”的依据。
//(4)进行打印"入度为0的顶点"的操作。即模拟出栈的操作`v=top;top=count[top]`,然后打印下标为v的顶点，此时top回退到上一个入度为0的顶点（即模拟的栈顶）。
//(5)进行模拟出栈操作后，将以出栈元素v为起始点的顶点元素(即第一个邻接顶点)的入度进行-1操作，如果-1之后入度为0，则该元素为新的栈顶元素，寻找下一个邻接顶点重复上述动作直至到达边链表的尾部
//(6)如果有向图中有环，那么在进行(4)(5)时，top的值从未改变，那么会一直回退到top==-1的状态，即在循环时，到达(3)的操作，会输出"有环",退出程序。
   //(1)
   int top = -1;
   Edge<Type> *p;
   for(int i=0; i<numVertices; ++i)
   {
       p = NodeTable[i].adj;
       while(NULL != p)
       {
           count[p->dest]++;
           p = p->link;
       }
   }
   //(2)
   for(int i=0; i<numVertices; ++i)
   {
        if(count[i] == 0)
        {
            count[i] = top;
            top = i;
        }
   }
   int v,w;
   for(int i=0; i<numVertices; ++i)
   {
       //(3)
        if(top == -1)
        {
            cout<<"无向图有环"<<endl;
            return false;
        }
        //(4)
        v = top;
        top = count[top];
        cout<<NodeTable[v].data<<"-->";
        w = GetFirstNeighbor(NodeTable[v].data);
        while(w != -1)
        {
            //(5)
            if(--count[w] == 0)
            {
                count[w] = top;
                top = w;
            }
            w = GetNextNeighbor(NodeTable[v].data, NodeTable[w].data);
        }
   }
   cout<<"over."<<endl;
   return true;
}

测试

//test.cpp
/*Test.cpp
**2016.2.16
*/
#include"GraphLink.h"
#include<vld.h>
int main()
{
    GraphLink<char> gl;
    gl.ShowGraph();
    gl.InsertVertex('A');
    gl.InsertVertex('B');
    gl.InsertVertex('C');
    gl.InsertVertex('D');
    gl.InsertVertex('E');
    /*gl.InsertEdge('A', 'B');
    gl.InsertEdge('A', 'C');
    gl.InsertEdge('B', 'E');
    gl.InsertEdge('C', 'D');
    gl.InsertEdge('D', 'B');
    gl.InsertEdge('E', 'D');*/
    gl.InsertVertex('F');
    gl.InsertEdge('A', 'B');
    gl.InsertEdge('A', 'C');
    gl.InsertEdge('A', 'D');
    gl.InsertEdge('C', 'E');
    gl.InsertEdge('C', 'B');
    gl.InsertEdge('D', 'E');
    gl.InsertEdge('E', 'G');
    gl.InsertEdge('F', 'D');
    gl.InsertEdge('F', 'E');
    gl.ShowGraph();
    gl.TopologicalSort();
}

测试结果
这里写图片描述
可以看到最后拓扑排序的结果是
F–>A–>C–>B–>D–>E–>over
在回忆一下原来的有向无环图：
这里写图片描述

逐鹿之城
关注
专栏目录
拓扑排序算法的实现与应用场景
一键难忘的博客
05-23 889
拓扑排序算法是一种解决有向无环图（DAG）排序问题的有效工具，其将图中的顶点以线性顺序排列，保证了依赖关系的正确顺序。本文介绍了拓扑排序算法的原理和实现方法，并探讨了其在不同领域的广泛应用场景。首先，我们了解了拓扑排序算法的基本原理，包括如何利用入度和队列来确定顶点的排序顺序。然后，我们通过 Python 示例代码演示了拓扑排序算法的实现过程，并验证了其在示例图中的正确性。接着，我们探讨了拓扑排序算法在实际应用中的多种场景。
拓扑排序：有向无环图的线性排序算法
m0_68805093的博客
08-20 114
拓扑排序C/C++代码实现
算法： 有向无环图(DAG)的拓扑排序
热门推荐
earayu的博客
10-22 1万+
定义： 拓扑排序是对有向无环图(DAG)的顶点的一种排序， 使得如果存在一条从v到w的路径，那么在排序中w就出现在v的后面。 如果图含有环，那么拓扑排序是不可能的。试想有3个正整数，a比b大，b比c大，c比a大，我们无法对abc排序。算法： 1. 一个简单的求拓扑排序的算法是先找出任意一个没有入边的顶点，然后将它和它的边从图中删除。然后对剩余部分使用同样的操作。 2. 另一种不那么直观，却更
实现有向无环图的拓扑排序
Missjust的博客
11-29 880
题目 用DFS和BFS实现如下有向无环图的拓扑排序： 解题思路 采用multimap存储这幅图，依次建立每个节点和它对应的后序节点组成的数组的映射。 代码如下： Graph.h #pragma once #include<iostream> #include<vector> #include<map> #include<queue> #includ...
算法 有向无环图 拓扑排序
baiiu
05-23 3559
1. 如何构造图 邻接矩阵(二维数组) 图的邻接矩阵存储方式是用两个数组来表示图，一个一维数组存储图中顶点信息，一个二维数组存储图中边或弧的信息。 邻接表 图中顶点信息用一个一维数组存储，还需存储指向第一个邻接点的指针，以便于查找该顶点的边信息。 其中每个顶点的所有邻接点构成一个线性表，由于邻接点的个数不定，所以用单链表存储。无向图成为顶点v的边表，有向图成为顶点v作为弧尾的出边表。等等其他表
有向无环图的应用
weixin_52847003的博客
11-26 1075
拓扑排序、关键路径
有向无环图的拓扑排序算法
zhangxiaojiakele的博客
03-19 1202
图的拓扑排序定义: 给定一幅有向图, 对图中各顶点排序, 使得对于图中的任意有向边v−>wv->wv−>w, 均满足节点vvv出现在节点www之前. 我们可以很容易证明, 存在环路的有向图无法进行排序. 假设当前有向图中存在某条环路v1−>v2−>...−>vk−>v1v_1->v_2->...->v_k->v_1v1​−&g...
java 有向无环图 树_拓扑排序-有向无环图（DAG, Directed Acyclic Graph）
weixin_42401356的博客
03-07 1831
条件：1.每个顶点出现且只出现一次。2.若存在一条从顶点 A 到顶点 B 的路径，那么在序列中顶点 A 出现在顶点 B 的前面。有向无环图(DAG)才有拓扑排序，非DAG图没有拓扑排序一说。一般用有向边指示顺序关系，运用于顺序关系。例如，下面这个图：显然是一个DAG图，1→4表示4的入度+1，4是1的邻接点,代码表示：前者deg[4]++;后者用vector[1].push(4)如何写出拓扑排序代...
算法导论生成一个100个点3000条边的有向无环图实验1-4
05-09
总之，"算法导论生成一个100个点3000条边的有向无环图实验1-4"涉及到图论、有向无环图的生成、强连通分量的识别以及与之相关的算法。通过这个实验，学生可以深入理解图数据结构的特性和应用，提升解决实际问题的能力...
Java 实现拓扑排序算法（源代码）
最新发布
05-16
### Java 实现拓扑排序算法（源代码） #### 拓扑排序算法介绍 拓扑排序（Topological Sorting...通过上述代码实现，我们可以清晰地看到拓扑排序的基本流程及其实现细节，有助于理解和应用拓扑排序算法解决实际问题。
深度优先搜索与有向无环图的拓扑排序(java实现）
04-10
NULL 博文链接：https://128kj.iteye.com/blog/1675685
深度优先算法（DFS）遍历有向无环图寻找最优路径
11-27
采用深度优先算法（DFS）遍历有向无环图寻找最优路径，经过优化的深度优先算法，在遍历有向无环图的时候保存路径，并计算路径权值，最总返回最优路径及最有路径的权值
【数据结构-图】有向无环图的应用
Mount256的博客
08-03 1258
【数据结构-图】有向无环图的应用
有向无环图及其应用
我的读书笔记（2011-2013）
12-15 707
有向无环图(Directed Acycling Graph)：是图中没有回路(环)的有向图。 对工程的活动加以抽象：图中顶点表示活动，有向边表示活动之间的优先关系，这样的有向图称为顶点表示活动的网(Activity On Vertex Network ，AOV网) 。 拓扑排序 由某个集合上的一个偏序得到该集合上的一个全序的操作。 算法实现说明 ◆ 采用正邻接链作为AOV网的存储结构；
有向无环图的应用——拓扑排序
狂放不羁霸的博客
07-12 2495
目录一、什么是AOV网？二、什么是拓扑排序？2.1 拓扑排序的定义2.2 拓扑排序的基本思想三、拓扑排序算法的实现3.1 算法思想3.1.1 设置辅助数组indegree[ ]3.1.2 设置辅助栈3.1.3 算法思想3.2 算法实现3.2.1 求入度3.2.2 拓扑排序AOV网：在一个表示工程的有向无环图中，用顶点表示活动，用弧表示活动间的优先关系，称这样的图为顶点表示活动的网（Activity On Vertex Network），简称为AOV网。 注意： 通过拓扑排序得到的拓扑序列使得AOV网中所
DAG(有向无环图) ------应用
smallgyy的专栏
05-30 3670
DAG是tree的泛化,也是ploy tree的泛化   In graph theory, polytree is a name for an oriented tree; that is, a polytree is a directed graph formed by giving a direction to each edge of a tree, forming an orienta
C语言实现：Prim-Kruskal-Dijkstra算法与拓扑排序详解
- **拓扑排序算法**：拓扑排序是对有向无环图（DAG）中的顶点进行排序，使得对于每条有向边(u, v)，顶点u都在顶点v之前。 2. **程序结构**：在实现这些算法时，需要遵循清晰的编程结构，包括模块化设计、输入输出...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值