Question

我最初有这种递归解决方案用于拓扑排序：

void dfs(int v, bool visited[], node* adjList[], std::stack<int> &myStack) {
    visited[v] = true;
    node* curr = adjList[v];

    while (curr != NULL) {
        if(!visited[curr->val]) {
            dfs(curr->val, visited, adjList, myStack);
        }
        curr = curr->next;
    }
    myStack.push(v);
}

它似乎适用于我的目的。但我无法将其转换为迭代解决方案。这是我的尝试：

void dfs(int v, bool visited[], node* adjList[], std::stack<int> &myStack) {
    std::stack<int> recursion;
    visited[v] = true;

    recursion.push(v);

    while( !recursion.empty() ) {
        v = recursion.top();
        recursion.pop();
        node* curr = adjList[v];

        myStack.push(v);

        while (curr != NULL) {
            if(!visited[curr->val]) {
                visited[curr->val] = true;
                recursion.push(curr->val);
            }
            curr = curr->next;
        }
    }
}

但订购完全搞砸了！我想这可能是由于myStack.push(v)的定位，但我不知道如何处理这个问题。任何帮助将不胜感激。

Answer 1

我想我解决了自己的问题。从本质上讲，您可以通过在节点完成时对节点进行排序来获得拓扑顺序。但是，我们可以将其保留为O（n），而不是进行排序并获得O（nlogn）解决方案。完成节点后，我们可以将节点的唯一标识符弹出到堆栈上，而不是记录其完成时间。由于在我的情况下我们只处理正顶点，所以将唯一标识符简单地设置为顶点值的负数就足够了。因此，如果我们连续弹出我们的堆栈，我们将获得拓扑顺序。

 void dfs(int v, bool visited[], node* adjList[], std::stack<int> &myStack) {
     std::stack<int> recursion;
     visited[v] = true;
     recursion.push(v);

     while( !recursion.empty() ) {
        v = recursion.top();
        recursion.pop();

        //A dummy node to denote finish order (e.g. topological order)
        if (v < 0) {
            myStack.push(v * -1);
        } else {
            node* curr = adjList[v];
            recursion.push(v * -1);

             while (curr != NULL) {
                if(!visited[curr->val]) {
                    visited[curr->val] = true;
                    recursion.push(curr->val);
                }
                curr = curr->next;
            }
        }
    }
}

拓扑排序使用迭代而不是递归

1 个答案: