Sorting 有向无环图的拓扑排序

有向无环图G可能有不同的拓扑排序吗？例如，在图形中：

A --> B --> D
      B --> E
A --> C --> E

---

我认为拓扑排序取决于运行深度优先搜索算法后每个顶点的完成时间。不是每个完成时间都是唯一的，因此G只能有一种拓扑排序吗？

是的。您可以通过多种方式遍历图形

在你的例子中，你可以有A，B，。。。。或者A，C

关于拓扑排序的wikipedia页面有一个更好的例子：

从上面引用的wiki页面：

如果拓扑排序的属性是 排序顺序中的顶点由边连接，然后是这些边 在DAG中形成有向哈密顿路径。如果是哈密顿路径 存在时，拓扑排序顺序唯一；没有其他订单 道路的边缘。相反，如果拓扑排序未形成 如果是哈密顿路径，DAG将具有两个或更多有效拓扑 订单，在这种情况下，始终可以形成第二个订单 通过交换两个不连续的顶点来进行有效排序 通过边缘相互连接。因此，可以进行测试 在线性时间内，是否存在唯一排序，以及 尽管哈密顿量具有NP硬度，但哈密顿量路径仍然存在 更一般有向图的路径问题（Vernet&Markenzon） 1997年）

公共类拓扑排序
{
私有int V；//顶点数
私有列表[]adj；//邻接列表
公共ToplogicalSort（int v）
{
V=V；
adj=新列表[v]；
对于（int i=0；i

刚找到答案，但不允许回答我自己的问题。Wikipedia显示，基于视觉排序（从左到右、从上到下）、从最小到最大顶点、最少边优先或任何其他任意条件，可以进行不同的拓扑排序。迭代推进

public class TopologicalSort
{
    private int V;   // No. of vertices
    private List<int> [] adj; // Adjacency List

    public ToplogicalSort(int v)
    {
        V = v;
        adj = new List<int>[v];
        for (int i=0; i < v; ++i)
            adj[i] = new List<int>();
    }

    public void AddEdge(int v,int w) { adj[v].Add(w); }

    public void TopologicalSortUtil(int v, bool[] visited, Stack<int> stack)
    {
        Stack<int> stackTracing = new Stack<int>();
        bool res = true;
        List<int> list = new List<int>(adj[v]);
        stackTracing.Push(v);
        while (stackTracing.Count != 0 | res)
        {
            int n = stackTracing.Peek();
            list = new List<int>(adj[n]);
            bool check = false;
            foreach (var elem in list)
            {
                if (!visited[elem])
                {
                    visited[elem] = true;
                    n = elem;
                    stackTracing.Push(elem);
                    check = true;
                    break;
                }
            }

            if(!check)
            {
                if(!stack.Contains(n))
                {
                    stack.Push(n);
                }
                if (stackTracing.Count != 0)
                    stackTracing.Pop();
                res = false;
            }           
        }
    }

    public void TopologicalSort()
    {
        Stack<int> stack = new Stack<int>();
        bool[] visited = new bool[V];
        for (int i = 0; i < V; i++)
            visited[i] = false;

        for (int i = 0; i < V; i++)
        {
            if (visited[i] == false)
            {
                topologicalSortUtil(i, visited, stack);
            }
        }
        // Print contents of stack
        while (stack.Count != 0)
        {
            stack.Pop();
            Console.WriteLine(stack.Pop() + " ");
        }
    }
    public static void RunSort()
    {
        TopologicalSort g = new TopologicalSort(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.TopologicalSort();
    }
}