Java 迭代DFS与递归DFS中的奇数排序

我正在解决这个问题

我编写了DFS的迭代版本和递归版本

节点访问的顺序不同，我不明白为什么

迭代DFS：

static void DFS (Integer root, Graph graph){

      //  System.out.println("DFS");

        HashSet <Integer> explored = new HashSet<Integer>();
             explored.add(root);

        Stack<Integer> stack = new Stack<Integer>();
              stack.add(root);

        int v; int w;


        while (!stack.isEmpty()){

            v=stack.pop();
            explored.add(v);

            System.out.print(v + " ");
           // for (int i=graph.adjacencies.get(v).size()-1; i>=0; i--) {
            for (int i=0; i < graph.adjacencies.get(v).size(); i++) {
                w = graph.adjacencies.get(v).get(i);

                if (!explored.contains(w)){

                    stack.add(w);
                    explored.add(w);
                }
            }

        }System.out.println();
    } 

静态无效DFS（整数根，图形）{
//System.out.println（“DFS”）；
HashSet explored=新HashSet（）；
添加（根）；
堆栈=新堆栈（）；
stack.add（root）；
int v；int w；
而（！stack.isEmpty（））{
v=stack.pop（）；
3.添加（v）；
系统输出打印（v+“”）；
//对于（inti=graph.adjaccies.get（v.size（）-1；i>=0；i--）{
for（inti=0；i

递归DFS：

static void DFS_2 (Integer root, Graph graph){

//        System.out.println("DFS_2");

        int v; int w;

        v = root;

        graph.explored.add(v);

            System.out.print(v + " ");
            for (int i=0; i < graph.adjacencies.get(v).size(); i++) {

                w = graph.adjacencies.get(v).get(i);

                if (!graph.explored.contains(w)){

                    graph.explored.add(w);
                    DFS_2(w, graph);
                }
            }


    }

static void DFS_2（整数根，图形）{
//System.out.println（“DFS_2”）；
int v；int w；
v=根；
图.添加（v）；
系统输出打印（v+“”）；
for（inti=0；i

关于教程问题，我对迭代DFS版本的输出是

1 4 3 2 6

虽然它应该是（根据问题样本输出和递归版本）：

1 3 2 6 4

这里发生了什么？为什么消除递归会改变访问的节点顺序

---

->.

因为堆栈。它是先入后出的，所以您将按照将节点的子节点添加到堆栈中的相反顺序查看它们

假设根的两个子元素是A和B，按照这个顺序（从左到右）

第一个算法：

柄根

向堆栈中添加一个

将B添加到堆栈中

从堆栈中弹出（因此为B，因为堆栈为FILO）

第二个算法：

柄根

处理

…照顾孩子

手柄B

---

您可以使用FIFO队列实现替换堆栈，这应该可以。

检查您的

图。邻接。get（V）

，它们是否为这两种情况提供相同的响应？如果是，则递归调用和堆栈调用将给出不同的结果。例如，类似以下的树：

      1
    2   3
  4

堆栈版本的顺序为

1->3->2->4

，递归版本的顺序为

1->2->4->3

，假设

graph.adjaccies.get（V）

始终首先返回左子级