1. 技术文章
  2. 拓扑排序

拓扑排序

由 做~自己de王妃 提交于 2020-02-25 11:41:48

在图论中，拓扑排序（Topological Sorting）是一个有向无环图（DAG, Directed Acyclic Graph）的所有顶点的线性序列。且该序列必须满足下面两个条件：

  1. 每个顶点出现且只出现一次。
  2. 若存在一条从顶点 A 到顶点 B 的路径，那么在序列中顶点 A 出现在顶点 B 的前面。

有向无环图（DAG）才有拓扑排序，非DAG图没有拓扑排序一说。

拓扑排序常用的两个方法

1、减治技术

  1. 从 DAG 图中选择一个 没有前驱（即入度为0）的顶点并输出。
  2. 从图中删除该顶点和所有以它为起点的有向边。
  3. 重复 1 和 2 直到当前的 DAG 图为空或当前图中不存在无前驱的顶点为止。后一种情况说明有向图中必然存在环。

所以拓扑排序结果是1、2、4、3、5

通常，一个有向无环图可以有一个或多个拓扑排序序列。

2、基于DFS来实现

执行一次DFS遍历，并记住顶点变成死端（即退出遍历栈）的顺序，将该次序反过来就得到拓扑排序的一个解。当然在遍历时，不能遇到回边，如果遇到一条回边，该图就不是一个有向无环图，并且对它的顶点进行拓扑排序是不可能的。

当一个顶点v退出DFS栈时，在比v更早出栈的顶点中，不可能存在一个顶点u拥有一条边从u指向v，否则就构成了一个回边。所以在退栈次序的队列中，任何这样的顶点都会排在v的后面，并且在逆序中排在v的前面。

算法：

（1）减治思想的程序，维护一个类Graph，类中定义邻接表list，入度为0的集合，以及每个顶点的入度。

#include<iostream>
#include <list>
#include <vector>
#include <queue>
using namespace std;
vector<vector<int> >sum;
vector<int> temp;
/************************类声明************************/
class Graph
{
    int V;             // 顶点个数
    list<int> *adj;    // 邻接表,图的表示方式
    queue<int> q;      // 维护一个入度为0的顶点的集合
    int* indegree;     // 记录每个顶点的入度
public:
    Graph(int V);                   // 构造函数
    ~Graph();                       // 析构函数
    void addEdge(int v, int w);     // 添加边
    bool topological_sort();        // 拓扑排序
    bool dfs(int u);
};

/************************类定义************************/
Graph::Graph(int V)
{
    this->V = V;
    adj = new list<int>[V];

    indegree = new int[V];  // 入度全部初始化为0
    for(int i=0; i<V; ++i)
        indegree[i] = 0;
}

Graph::~Graph()
{
    delete [] adj;
    delete [] indegree;
}
vector<int> c;
void Graph::addEdge(int v, int w)
{
    adj[v].push_back(w); 
    ++indegree[w];
}
bool Graph::topological_sort()
{
    for(int i=0; i<V; ++i)
        if(indegree[i] == 0)
            q.push(i);         // 将所有入度为0的顶点入队

    int count = 0;             // 计数，记录当前已经输出的顶点数 
    while(!q.empty())
    {
        int v = q.front();      // 从队列中取出一个顶点
        q.pop();

        cout << v << " ";      // 输出该顶点
        ++count;
        // 将所有v指向的顶点的入度减1，并将入度减为0的顶点入栈
        list<int>::iterator beg = adj[v].begin();
        for( ; beg!=adj[v].end(); ++beg)
            if(!(--indegree[*beg]))
                q.push(*beg);   // 若入度为0，则入栈
    }

    if(count < V)
        return false;           // 没有输出全部顶点，有向图中有回路
    else
        return true;            // 拓扑排序成功
}
int main()
{
    Graph g(6);   // 创建图
    g.addEdge(5, 2);
    g.addEdge(5, 0);
    g.addEdge(4, 0);
    g.addEdge(4, 1);
    g.addEdge(2, 3);
    g.addEdge(3, 1);
    g.topological_sort();
    return 0;
}

（2）基于DFS的算法

#include<iostream>
#include <list>
#include <vector>
#include <queue>
using namespace std;
vector<vector<int> >sum;
vector<int> temp;
/************************类声明************************/
class Graph
{
    int V;             // 顶点个数
    list<int> *adj;    // 邻接表
    queue<int> q;      // 维护一个入度为0的顶点的集合
    int* indegree;     // 记录每个顶点的入度
public:
    Graph(int V);                   // 构造函数
    ~Graph();                       // 析构函数
    void addEdge(int v, int w);     // 添加边
    bool topological_sort();        // 拓扑排序
    bool dfs(int u);
    void print();
};

/************************类定义************************/
Graph::Graph(int V)
{
    this->V = V;
    adj = new list<int>[V];

    indegree = new int[V];  // 入度全部初始化为0
    for(int i=0; i<V; ++i)
        indegree[i] = 0;
}

Graph::~Graph()
{
    delete [] adj;
    delete [] indegree;
}
vector<int> c;//用来标记是否被访问
void Graph::addEdge(int v, int w)
{
    adj[v].push_back(w); 
    ++indegree[w];
}
vector<int>TopNum;//用来存放最后的拓扑排序结果，最先返回的在最后
int t;
bool Graph::dfs(int u)//从一个节点开始，找出dfs序列，返回该节点之后是否存在一个拓扑序列，只要之后遍历到的点和之前的点u有关系（v->u），那么就说明成环！返回false。 
{
    c[u]=-1;//-1表示已经访问过，0表示未访问过
    list<int>::iterator beg = adj[u].begin();
    for( ; beg!=adj[u].end(); ++beg)
    {
            if(c[*beg]==-1)
        {//大水冲了龙王庙，这个i点在之前已经被遍历到了，成环！
                return false;       
            }
            if(!c[*beg]&&!dfs(*beg)) 
        return false;
     }
        //经过了检验
        c[u]=1;//对应的c不能是-1，也不能是0
        TopNum[--t]=u;//逆序存放
        return true;
}
bool Graph::topological_sort()
{
    int h=V;
    t=V;
    for(int i=0;i<h;i++)
    {
        c.push_back(0); 
        TopNum.push_back(0);
    }
    for(int i=0;i<h;i++)
        if(!c[i])
            if(!dfs(i))
                return false;
    return true;            
}
void Graph::print()//输出邻接表，为了检验是否完成图的构造
{
    for(int i=0;i<V;i++)
    {
        list<int>::iterator beg = adj[i].begin();
        for( ; beg!=adj[i].end(); ++beg)
        {
            cout<<*beg<<'\0';
        }
    }
}
int main()
{
    Graph g(6);   // 创建图
    g.addEdge(5, 2);
    g.addEdge(5, 0);
    g.addEdge(4, 0);
    g.addEdge(4, 1);
    g.addEdge(2, 3);
    g.addEdge(3, 1);
    //g.print();
    cout<<g.topological_sort()<<endl;
    for(int i=0;i<TopNum.size();i++)
    {
    cout<<TopNum[i]<<'\0';
    }
    return 0;
}

另外一种dfs代码

#include<iostream>
#include <list>
#include <stack>
using namespace std;

class Graph
{
    int V;    // 顶点数

    list<int> *adj;//指向邻接表
    void topologicalSortUtil(int v, bool visited[], stack<int> &Stack);
public:
    Graph(int V);   // 构造函数
 
     // 加入边
    void addEdge(int v, int w);
 
    // 输出拓扑排序的一个序列
    void topologicalSort();
};
 
Graph::Graph(int V)
{
    this->V = V;
    adj = new list<int>[V];
}
 
void Graph::addEdge(int v, int w)
{
    adj[v].push_back(w); // Add w to v’s list.
}
 
// A recursive function used by topologicalSort
void Graph::topologicalSortUtil(int v, bool visited[], 
                                stack<int> &Stack)
{
    // 用来标记节点是否被访问
    visited[v] = true;
 
    // Recur for all the vertices adjacent to this vertex
    list<int>::iterator i;
    for (i = adj[v].begin(); i != adj[v].end(); ++i)
        if (!visited[*i])//如果该节点没有被访问，则调用dfs函数
            topologicalSortUtil(*i, visited, Stack);
 
    // 把当前节点打入栈中
    Stack.push(v);
}
 
// 拓扑排序函数，用到了topologicalSortUtil函数
void Graph::topologicalSort()
{
    stack<int> Stack;
 
    bool *visited = new bool[V];
    for (int i = 0; i < V; i++)
        visited[i] = false;//初始化为false，表示未被访问过
 
    // 挨个遍历节点，对每个节点进行dfs遍历
    for (int i = 0; i < V; i++)
      if (visited[i] == false)
        topologicalSortUtil(i, visited, Stack);
 
    // Print contents of stack
    while (Stack.empty() == false)
    {
        cout << Stack.top() << " ";
        Stack.pop();
    }
}

int main()
{
    // Create a graph given in the above diagram
    Graph g(6);
    g.addEdge(5, 2);
    g.addEdge(5, 0);
    g.addEdge(4, 0);
    g.addEdge(4, 1);
    g.addEdge(2, 3);
    g.addEdge(3, 1);
 
    cout << "Following is a Topological Sort of the given graph \n";
    g.topologicalSort();
    return 0;
}

那如果要输出全部的路径呢，比如我需要知道图中所有可行的路径，上图中就是[5,2,3,1]，[5,0]，[4,0]，[4,1]

我选择用dfs的方式，来输出全部的路径。就是找到入度为0的节点，因为所有的路径一定都是从这些节点出发的，然后依次找这些节点的深度优先遍历（在这些节点的邻接表中找），每遍历到一个节点，都将它打入一个vector中，再遍历该节点邻接的一个节点，直到没有后续的路之后（当前节点邻接表为空），将vector放入sum中，每次从入度为0的一个节点开始时，都将temp清零一下，因为这是全新的一个路径。如果到了一个顶点的邻接表尽头，意味着没有再和它相连的点了，那么temp要把该节点pop出来，以便存放另外一个路径。最后，sum的大小就是路径的个数，sum中的序列就是所有的路径。

#include<iostream>
#include <list>
#include <vector>
#include <stack>
using namespace std;
class Graph
{
    int V;   
 
    list<int> *adj;
 
    bool topologicalSortUtil(int v, bool visited[], stack<int> &Stack);
    int* indegree;     // 记录每个顶点的入度
public:
    Graph(int V);   
 
    void addEdge(int v, int w);
 
    void topologicalSort();
    void printall();
};
vector<vector<int> > sum;
vector<int> temp;
Graph::Graph(int V)
{
    this->V = V;
    adj = new list<int>[V];
    indegree = new int[V];  // 入度全部初始化为0
    for(int i=0; i<V; ++i)
        indegree[i] = 0;
}
 
void Graph::addEdge(int v, int w)
{
    adj[v].push_back(w); 
    ++indegree[w];
}
void Graph::printall()
{
    stack<int> Stack;
    bool *visited = new bool[V];
        for (int i = 0; i < V; i++)
            visited[i] = false;
    for(int i=0;i<V;i++)
    {
        if(indegree[i]==0 && visited[i] == false)
        {
            if(topologicalSortUtil(i, visited, Stack))
            {
                temp.clear();
                continue;
            }
            return;
        }
    }
}
 
bool Graph::topologicalSortUtil(int v, bool visited[], 
                                stack<int> &Stack)
{
    visited[v] = true;
    temp.push_back(v);
    // Recur for all the vertices adjacent to this vertex
    list<int>::iterator i;
    for (i = adj[v].begin(); i != adj[v].end(); )
    {
        if (!visited[*i])
            topologicalSortUtil(*i, visited, Stack);
        if(++i==adj[v].end())
        {
            temp.pop_back();
        }
    }
    if(adj[v].empty())
    {
        sum.push_back(temp);
        temp.pop_back();
    }
    visited[v]=false;
    // Push current vertex to stack which stores result
    Stack.push(v);
    return true;
}
int main()
{
    // Create a graph given in the above diagram
    Graph g(6);
    g.addEdge(5, 2);
    g.addEdge(5, 0);
    g.addEdge(4, 0);
    g.addEdge(4, 1);
    g.addEdge(2, 3);
    g.addEdge(3, 1);
    g.addEdge(5,4);
    //Graph g(5);
 //   g.addEdge(1,4);
 //   g.addEdge(0,1);
 //   g.addEdge(0,2);
 //   g.addEdge(3,4);

    g.printall();
    cout<<sum.size()<<endl;
    for(int i=0;i<sum.size();i++)
    {
        for(int j=0;j<sum[i].size();j++)
        {
            cout<<sum[i][j]<<'\0';
        }
        cout<<endl;
    }
    return 0;
}

 

标签
拓扑排序
vector初始化
vector
易学教程内所有资源均来自网络或用户发布的内容，如有违反法律规定的内容欢迎反馈！
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!