给定一个有向图，图节点的拓扑排序被定义为：

• 对于每条有向边A--> B，则A必须排在B之前
• 拓扑排序的第一个节点可以是任何在图中没有其他节点指向它的节点

找到给定图的任一拓扑排序

solution

Topological Sorting

Topological sorting for Directed Acyclic Graph (DAG) is a linear ordering of vertices such that for every directed edge uv, vertex u comes before v in the ordering. Topological Sorting for a graph is not possible if the graph is not a DAG.

For example, a topological sorting of the following graph is “5 4 2 3 1 0″. There can be more than one topological sorting for a graph. For example, another topological sorting of the following graph is “4 5 2 3 1 0″. The first vertex in topological sorting is always a vertex with in-degree as 0 (a vertex with no in-coming edges).

Topological Sorting vs Depth First Traversal (DFS):
In DFS, we print a vertex and then recursively call DFS for its adjacent vertices. In topological sorting, we need to print a vertex before its adjacent vertices. For example, in the given graph, the vertex ‘5’ should be printed before vertex ‘0’, but unlike DFS, the vertex ‘4’ should also be printed before vertex ‘0’. So Topological sorting is different from DFS. For example, a DFS of the above graph is “5 2 3 1 0 4″, but it is not a topological sorting

Algorithm to find Topological Sorting:
We recommend to first see implementation of DFS here. We can modify DFS to find Topological Sorting of a graph. In DFS, we start from a vertex, we first print it and then recursively call DFS for its adjacent vertices. In topological sorting, we use a temporary stack. We don’t print the vertex immediately, we first recursively call topological sorting for all its adjacent vertices, then push it to a stack. Finally, print contents of stack. Note that a vertex is pushed to stack only when all of its adjacent vertices (and their adjacent vertices and so on) are already in stack.

引用自 http://www.geeksforgeeks.org/topological-sorting/

如果仅仅只是对DAG进行DFS，那么针对某一起始点（例如上图中的5）开始的DFS确实可以满足Topological sorting，但是当对该点DFS范围以外的其他点（例如上图中的4）再进行DFS时，很可能会出现不满足Topological sorting的情况。例如上图中，在4指向1的清凉下。那如何解决？

利用栈后进先出的性质，我们可以依次递归的将每一个vertex的adjacent vertices先入栈，vertex最后入栈，这样vertices的出栈顺序即满足Topological sorting，代码如下：

// Author: Jian-xin Zhou

/**
 * Definition for Directed graph.
 * struct DirectedGraphNode {
 *     int label;
 *     vector<DirectedGraphNode *> neighbors;
 *     DirectedGraphNode(int x) : label(x) {};
 * };
 */
class Solution {
public:
    /**
     * @param graph: A list of Directed graph node
     * @return: Any topological order for the given graph.
     */
    vector<DirectedGraphNode*> topSort(vector<DirectedGraphNode*> graph) {
        // write your code here
        unordered_set<DirectedGraphNode*> unique;
        stack<DirectedGraphNode*> st;
        topologicalSort(graph, unique, st);
        
        vector<DirectedGraphNode*> ret;
        while (!st.empty()) {
            ret.push_back(st.top());
            st.pop();
        }
        
        return ret;
    }
    
private:
    void topologicalSortUtil(DirectedGraphNode *node, 
                             unordered_set<DirectedGraphNode*> &unique,
                             stack<DirectedGraphNode*> &st) {
            // 处理 neighbors
            for (const auto &nodePointer : node->neighbors) {
                if (unique.count(nodePointer) == 0) {
                    unique.insert(nodePointer);
                    topologicalSortUtil(nodePointer, unique, st);
                }
            }  
            
            // 处理完 neighbors ,自身入栈
            st.push(node);
    }
    
    void topologicalSort(vector<DirectedGraphNode*> graph,
                         unordered_set<DirectedGraphNode*> &unique,
                         stack<DirectedGraphNode*> &st) {
        for (const auto &node : graph) {
            if (unique.count(node) == 0) {
                unique.insert(node);
                topologicalSortUtil(node, unique, st);
            }
        }                         
    }
};