前中后序遍历，层次遍历（递归和非递归法）

原创 已于 2024-05-14 19:52:47 修改 · 409 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#windows

于 2019-12-03 22:15:47 首次发布

四种主要的遍历思想为：

前序遍历：根结点 —> 左子树 —> 右子树

中序遍历：左子树—> 根结点 —> 右子树

后序遍历：左子树 —> 右子树 —> 根结点

层次遍历：只需按层次遍历即可
在这里插入图片描述

前序遍历

  • 递归法：
public class LC144 {
    //递归法：
    public List<Integer> preorderTraversal(TreeNode root) {
        ArrayList<Integer> list = new ArrayList<>();
        if (root == null) {
            return list;
        }
        helper(root, list);
        return list;
    }

    private void helper(TreeNode root, ArrayList<Integer> list) {
        if (root == null) {
            return;
        }
        list.add(root.val);
        helper(root.left, list);
        helper(root.right, list);
    }
}

  

  • 非递归法：
public class LC144 {
    //非递归法：
    public List<Integer> preorderTraversal(TreeNode root) {
        ArrayList<Integer> list = new ArrayList<>();
        if (root == null) {
            return list;
        }
        Stack<TreeNode> stack = new Stack<TreeNode>();
        stack.push(root);
        while (!stack.isEmpty()) {
            root = stack.pop(); //或者写成 TreeNode tmp = stack.pop();
            list.add(root.val);
            if (root.right != null) {
                stack.push(root.right);
            }
            if (root.left != null) {
                stack.push(root.left);
            }
        }
        return list;
    }
}

  

中序遍历

  • 递归法：
public class LC94 {
    //递归法：
    public List<Integer> inorderTraversal(TreeNode root) {
        ArrayList<Integer> list = new ArrayList<>();
        if (root == null) {
            return list;
        }
        helper(root, list);
        return list;
    }

    private void helper(TreeNode root, ArrayList<Integer> list) {
        if (root == null) {
            return;
        }
        helper(root.left, list);
        list.add(root.val);
        helper(root.right, list);
    }
}

  

  • 非递归法：
public class LC94 {
    //非递归法：
    public List<Integer> inorderTraversal(TreeNode root) {
        ArrayList<Integer> list = new ArrayList<>();
        if (root == null) {
            return list;
        }
        Stack<TreeNode> stack = new Stack<>();
        while (!stack.isEmpty() || root != null) {
            if (root != null) {
                stack.push(root);
                root = root.left;
            } else {
                root = stack.pop();
                list.add(root.val);
                root = root.right;
            }
        }
        return list;
    }
}

  

后序遍历

  • 递归法：
public class LC145 {
    //递归法
    public List<Integer> postorderTraversal(TreeNode root) {
        ArrayList<Integer> list = new ArrayList<>();
        if (root == null) {
            return list;
        }
        helper(root, list);
        return list;
    }

    private void helper(TreeNode root, ArrayList<Integer> list) {
        if (root == null) {
            return;
        }
        helper(root.left, list);
        helper(root.right, list);
        list.add(root.val);
    }
}

  

  • 非递归法：
public class LC145 {
    //非递归法
    public List<Integer> postorderTraversal(TreeNode root) {
        ArrayList<Integer> list = new ArrayList<>();
        if (root == null) {
            return list;
        }
        Stack<TreeNode> s1 = new Stack<>();
        Stack<TreeNode> s2 = new Stack<>();
        s1.push(root);
        while (!s1.isEmpty()) {
            root = s1.pop(); //或者写成 TreeNode tmp = s1.pop();
            s2.push(root);
            if (root.left != null) {
                s1.push(root.left);
            }
            if (root.right != null) {
                s1.push(root.right);
            }
        }
        while (!s2.isEmpty()) {
            list.add(s2.pop().val);
        }
        return list;
    }
}

  

层次遍历

  • 递归法：
public class LC102 {
	//递归法
    public List<List<Integer>> levelOrderDFS(TreeNode root) {
        ArrayList<List<Integer>> lists = new ArrayList<>();
        helper(root, 0, lists);
        return lists;
    }

    private void helper(TreeNode root, int level, ArrayList<List<Integer>> lists) {
        if (root == null) {
            return;
        }
        //当前层还没有元素，先new一个空的列表
        if (lists.size() <= level) {
            lists.add(new ArrayList<>());
        }
        lists.get(level).add(root.val);
        helper(root.left, level + 1, lists);
        helper(root.right, level + 1, lists);
    }
}

  

  • 非递归：
    //如果要求每层节点分类存储
    public ArrayList<ArrayList<Integer>> levelOrder(TreeNode root) {
        ArrayList<ArrayList<Integer>> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        LinkedList<TreeNode> list = new LinkedList<>();
        list.add(root);
        int level = 0;
        while (!list.isEmpty()) {
            res.add(new ArrayList<>());
            int len = list.size();
            for (int i = 0; i < len; i++) {
                TreeNode node = list.pop();
                res.get(level).add(node.val);
                if (node.left != null) {
                    list.add(node.left);
                }
                if (node.right != null) {
                    list.add(node.right);
                }
            }
            level++;
        }
        return res;
    }

整体：

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Stack;

public class Order {
    public void preOrder(Node head) {
        if (head == null) {
            return;
        }
        Stack<Node> s = new Stack<>();
        s.push(head);
        while (!s.isEmpty()) {
            head = s.pop();
            System.out.println(head.val);
            if (head.right != null) {
                s.push(head.right);
            }
            if (head.left != null) {
                s.push(head.left);
            }
        }
    }

    public void inOrder(Node head) {
        if (head == null) {
            return;
        }
        Stack<Node> s = new Stack<>();
        while (!s.isEmpty() || head != null) {
            if (head != null) {
                s.push(head);
                head = head.left;
            } else {
                head = s.pop();
                System.out.println(head.val + " ");
                head = head.right;
            }
        }
    }

    public void postOrder(Node head) {
        if (head == null) {
            return;
        }
        Stack<Node> s1 = new Stack<>();
        Stack<Node> s2 = new Stack<>();
        s1.push(head);
        while (!s1.isEmpty()) {
            head = s1.pop();
            s2.push(head);
            if (head.left != null) {
                s1.push(head.left);
            }
            if (head.right != null) {
                s1.push(head.right);
            }
        }
        while (!s2.isEmpty()) {
            System.out.println(s2.pop().val + " ");
        }
    }

    public ArrayList<ArrayList<Integer>> levelOrder(Node head) {
        ArrayList<ArrayList<Integer>> res = new ArrayList<>();
        if (head == null) {
            return res;
        }
        LinkedList<Node> list = new LinkedList<>();
        list.add(head);
        int level = 0;
        while (!list.isEmpty()) {
            res.add(new ArrayList<>());
            int len = list.size();
            for (int i = 0; i < len; i++) {
                Node node = list.pop();
                res.get(level).add(node.val);
                if (node.left != null) {
                    list.add(node.left);
                }
                if (node.right != null) {
                    list.add(node.right);
                }
            }
            level++;
        }
        return res;
    }

    /**
     * 递归思路
     */
    public void preOrderR(Node head) {
        if (head == null) {
            return;
        }
        System.out.println(head.val + " ");
        preOrderR(head.left);
        preOrderR(head.right);
    }

    public void inOrderR(Node head) {
        if (head == null) {
            return;
        }
        inOrderR(head.left);
        System.out.println(head.val + " ");
        inOrderR(head.right);
    }

    public void postOrderR(Node head) {
        if (head == null) {
            return;
        }
        postOrderR(head.left);
        postOrderR(head.right);
        System.out.println(head.val + " ");
    }
}
遍历的三种算法——递归、非递归、层次
zxf347085420的博客
02-23 797
原文链接：https://blog.youkuaiyun.com/weixin_46432495/article/details/120497774。
层次遍历的递归实现 Java
r'q'x't 的博客
05-13 2755
定义一个全局的二维列表。 二维列表的索引就是该元素所位于的层数。例如：索引 0，代表位于第0层（即根节点所在层）。 递归的时候，多加一个参数（当前层+1）即可。
算法：二叉树的层次遍历（递归实现）
热门推荐
weixin_34236869的博客
03-07 1万+
二叉树知识参考：深入学习二叉树(一) 二叉树基础 递归实现层次遍历算法参考：【面经】用递归方法对二叉树进行层次遍历 && 二叉树深度 上面第一遍基础写得不错，不了解二叉树的值得一看。然后，主要说说用递归来实现二叉树的层次遍历。 先上代码： 1 local function FindTree(tree, level) 2 if(tree ==...
二叉树先序、中序、后序、层次遍历递归以及非递归算法实现
shijiujiu33的博客
08-17 2059
最近写了一下关于二叉树的三种遍历算法的递归以及非递归实现，以及层次遍历算法实现 先序遍历递归实现 /** * 先序遍历，根》左》右 */ public void beforeTraverse(TreeNode root) { if (root == null) { return; } System...
二叉树的层次遍历-基于递归方法
一匹刚学打乒乓球的老马
11-11 1733
在前面介绍了二叉树的层次遍历，是用非递归算法实现的。 本文，我们基于递归算法实现。 #include<queue> #include<iostream> using namespace std; struct node {//树的结点结构。二叉链表表示法 char data; node *lchild,*rchild; }; void layerTraverseRecurve(queue<node*> &q) {//递归部分 if(q.empt
二叉树后序遍历（递归法和迭代法(非递归法)）——C++
净无邪博客
12-04 2166
一、二叉树后序遍历 后序遍历是先遍历左子节点left，在遍历右子节点right，最后遍历父节点parent，即遍历顺序：1.2 迭代法 由于后续遍历如果按照正常迭代思路去实现将不好理解和实现，仔细观察下面前序和后续遍历顺序，可以发现一个规律： 前序遍历：parent ——> left ——> right 前序遍历： left ——> right ——>parent， 将后续遍历逆序过来遍历，则：parent ——> right ——>left 通过观察1和3可以发现，两者都是先遍历父节点，再遍历左
二叉树的前序、中序、后序遍历（递归、非递归写法）
m0_62021646的博客
05-13 2129
文章目录一、什么是二叉树？二、二叉树的基本概念三、二叉树的三种遍历方式1.前序遍历（preordertraversal）1.中序遍历（inordertraversal）1.后序遍历（postordertraversal）四、代码实现1.建树过程2.递归写法3.非递归写法4.完整代码 一、什么是二叉树？ 二叉树（Binary tree）是树形结构的一个重要类型。许多实际问题抽象出来的数据结构往往是二叉树形式，即使是一般的树也能简单地转换为二叉树，而且二叉树的存储结构及其算法都较为简单，因此二叉树显得特别重要。
Java中的二叉树，前中后序遍历的递归和迭代写法。
回水的博客
06-15 1424
文章目录一、树是什么？树的特点二、二叉树1.概念及特点2.读入数据总结 一、树是什么？ 树是一种非线性的数据结构，它是由n(n >= 0)个有限结点组成的一个具有层次关系的集合。(线性数据结构就是：线性表，数组，栈，链表，队列，字符串…元素之间逻辑上一个挨着一个，呈值直线排列)把它叫做树是因为它看起来像一颗倒着的树，意思就是根朝上，叶子朝下。 树的特点 有一个特殊的结点，称为根节点，根节点没有前驱结点。 除根节点外，其余节点被分成M(M > 0) 个互不相交的集合T1、T2、…、Tm,其中
二叉树的前中后序以及层序遍历（递归与非递归方法实现）
tensor329的博客
04-01 758
1.前序遍历 前序遍历是二叉树遍历的一种方式，也称做先序遍历。其遍历规则为：根节点→左子树→右子树。以下分别以递归和非递归的方法实现对二叉树的前序遍历。 1.1 递归方法 class Solution { List<Integer> res=new ArrayList<>(); public List<Integer> preorderTraversal(TreeNode root) { if(root!=null){
二叉树前、中、后、层次、遍历的非递归法
weixin_34390996的博客
03-11 201
一、二叉树 非递归前序遍历 class Solution { public List<Integer> preorderTraversal(TreeNode root) { List<Integer> res = new ArrayList<>(); if(root == null) return res; ...
数据结构 - 前中后序遍历
weixin_43191747的博客
04-03 365
方法三：莫里斯遍历：在第二次到达时，然后逆序打印左子树的右边界，最后打印整棵树的右边界。如果cur有左孩子，找到cur左子树上最右的节点，记为mostRight。如果一个节点有左子树，可以到达两次，而且在第二次到达时，其左子树遍历完毕。如果cur无左孩子，cur向右移动, cur = cur.right。在介绍具体代码之前，先简述一下 莫里斯遍历 相关内容。若没有左子树，则只能到达一次。来到当前节点，记为cur。：不使用任何辅助空间。
二叉树按层次遍历的递归用法
YaoDeBiAn的博客
06-07 8529
对于在学数据结构的大家，在编写二叉树的按层次遍历时往往会用非递归的方法，或许有人会问可不可以用递归来做呢？ 对此，小编的答案是可以的。 相对于非递归，递归稍微要复杂些（这是由于二叉树中递归左子树递归右子树是完全与层次遍历相悖的），为此需要借助其他函数来实现 下面是小编写的按层次递归遍历二叉树的代码： 小编的思路是这样的：先编写几个函数，它们的功能分别是：计算二叉树的深度（BitreeDep
二叉树先序、中序、后序、层序遍历的递归和非递归实现
Shrimp_millet
07-09 361
先序、中序、后序三种递归遍历： //先序遍历 void preOrder(TreeNode* head) { if(!head) return; cout<<head->val<<" "; if(head->left) preOrder(head->left); if(head->right) preOrder(head->righ...
前中后序二叉树遍历迭代方法总结
fruit513的博客
12-27 708
//inorder public List&lt;Integer&gt; inorderTraversal(TreeNode root) { List&lt;Integer&gt; res=new ArrayList&lt;&gt;(); if (root==null) return res; Stack&lt;TreeNode&gt; s...
前中后序遍历的递归与非递归算法，层序遍历
qq_55439426的博客
02-25 2507
水到，渠成
中序遍历非递归实现（java实现）自己写的虽然与课本不一样，但是也是对的。...
松篁
10-04 223
import java.util.*; class Node{ int data; Node lchild; Node rchild; Node(int a) { data=a; lchild=null; rchild=null; } } public class InOrderTravereseFeidigui{ private static final Sta...
中序遍历--递归和非递归（java版）
文艺的小码农专栏
11-21 8606
根据中序遍历的顺序，对于任一结点，优先访问其左孩子，而左孩子结点又可以看做一根结点，然后继续访问其左孩子结点，直到遇到左孩子结点为空的结点才进行访问，然后按相同的规则访问其右子树。因此其处理过程如下： 　　对于任一结点root，引入一个辅助节点p，其作用是：标记已经访问过的节点， 　1)将root压入栈中，只有有左孩子，就压入栈中 if(p!=null &amp;&...
层次遍历的非递归算法
Jacgu的博客
11-28 1307
层次遍历的非递归算法 上代码（用队列实现） 语言（c++） #include <iostream> #include "btree.h" #include <stdio.h> using namespace std; int main() { BTNode *p,*q; char str[MaxSize],m; printf("\n(1)创建二叉树，请以括号表示法输入二叉树：\n"); gets(str); CreateBTNode(p,st
二叉树的后序遍历 后序遍历 二叉树的后序遍历，就是先递归后序遍历左子树，再递归后序遍历右子树，最后输出根结点的值 代码如下： public void postOrder(TreeNode root){ if(root == null){ return; } postOrder(root.left); postOrder(root.right); system.out.println(root.data); }
最新发布
04-24
<think>好的，我现在需要帮助用户理解二叉树后序遍历的非递归实现方法，并提供代码解析。用户之前已经询问过先序遍历的非递归实现，现在转向后序，所以我需要确保解释清晰，并比较两者的不同。 首先，我得回忆后序遍历的顺序是左-右-根，这意味着在处理当前节点之前，必须先访问完左右子树。非递归实现通常需要使用栈来模拟递归过程，但后序的情况比先序和中序更复杂，因为需要跟踪节点的访问状态。 根据用户提供的引用[1]，里面提到后序遍历的非递归写法最难，可能需要双栈法或标记法。引用[4]中的中序遍历代码使用了一个栈，通过移动指针来遍历左子树，然后处理根节点和右子树。但后序需要更多的控制，确保左右子树都被访问过才能处理当前节点。 标记法可能更容易理解，即在栈中存储节点和访问状态的组合。例如，使用一个标记来指示节点是否是第一次弹出。如果是第一次，则重新入栈并处理右子节点，第二次弹出时才访问节点值。这种方法可以确保左右子树处理完毕后再处理根节点。 另外，引用[5]提到Java的后台开发中使用AOF重写机制，但可能和当前问题无关，可以忽略。引用[3]中的练习题可能涉及遍历的应用，但用户现在需要的是实现方法。 我需要一步步拆解代码，解释每个步骤的作用。例如，使用栈来保存节点和标记，初始时压入根节点和未访问状态。然后循环处理栈顶元素，根据标记决定是处理子节点还是访问当前节点。 同时，需要比较先序、中序和后序的不同之处。例如，先序在入栈时访问节点，后序则需要在第二次弹出时访问。还要注意入栈顺序，确保左子节点先处理，然后是右子节点，最后是根节点。 还需要考虑边界情况，比如空树或单节点的情况。代码中需要检查root是否为null，并返回空列表。栈的操作需要正确，避免空指针异常。 最后，给出时间复杂度分析，说明时间和空间复杂度都是O(n)，因为每个节点入栈两次，但总次数仍与节点数成线性关系。空间复杂度由栈的深度决定，最坏情况下是O(n)，平衡树时为O(log n)。 可能用户还会想知道为什么后序遍历比其他遍历难，所以需要解释跟踪节点的必要性，以及如何通过标记法解决这个问题。同时，引用相关参考资料中的信息，如[^1]和[^4]，来支持解释的正确性。</think>### 二叉树后序遍历的非递归实现及代码解析 后序遍历的顺序是**左子树 → 右子树 → 根节点**。非递归实现的核心难点在于：**必须确保左右子树都被访问后才能处理当前节点**。这里提供两种主流实现方法，并给出详细解析。 --- #### 方法一：双栈法（反向先序） **核心思想**：通过调整先序遍历的入栈顺序（根 → 右 → 左），将结果反向输出即可得到后序序列。 ```java public List<Integer> postOrderNonRecursive(TreeNode root) { List<Integer> result = new ArrayList<>(); if (root == null) return result; Stack<TreeNode> stack = new Stack<>(); Stack<Integer> output = new Stack<>(); // 辅助栈用于反向输出 stack.push(root); while (!stack.isEmpty()) { TreeNode node = stack.pop(); output.push(node.val); // 先存入辅助栈 if (node.left != null) stack.push(node.left); // 注意入栈顺序 if (node.right != null) stack.push(node.right); } while (!output.isEmpty()) { result.add(output.pop()); // 反向输出即为后序序列 } return result; } ``` **步骤解析**（以二叉树 `1 -> 2(左),3(右)` 为例）： 1. **主栈初始化**：`1`入栈 2. **第一次循环**： - 弹出`1`，存入辅助栈 → `output=[1]` - `2`和`3`按左→右顺序入主栈 → `stack=[2,3]` 3. **第二次循环**： - 弹出`3`，存入辅助栈 → `output=[1,3]` - `3`的左右子节点为空 4. **第三次循环**： - 弹出`2`，存入辅助栈 → `output=[1,3,2]` 5. **反向输出**：最终结果为`2 → 3 → 1` --- #### 方法二：标记法（单栈追踪状态） **核心思想**：用栈存储节点及其访问状态，通过两次入栈操作控制处理顺序[^1][^4]。 ```java public List<Integer> postOrderWithTag(TreeNode root) { List<Integer> result = new ArrayList<>(); if (root == null) return result; Stack<Object> stack = new Stack<>(); stack.push(root); while (!stack.isEmpty()) { Object obj = stack.pop(); if (obj instanceof TreeNode) { TreeNode node = (TreeNode) obj; stack.push(node.val); // 第一次弹出：节点值作为标记 stack.push(node.right); // 右子先处理 stack.push(node.left); // 左子后处理 } else { result.add((Integer) obj); } } return result; } ``` **步骤解析**（以二叉树 `1 -> 2(左),3(右)` 为例）： 1. **初始状态**：栈中仅根节点`1` 2. **第一次弹出**：发现是`TreeNode`类型 - 将`1.val`、`1.right`、`1.left`按顺序压栈 → `stack=[1.val,3,2]` 3. **处理左子树**： - 弹出`2`，再次压入`2.val`、`2.right`、`2.left` → `stack=[1.val,3,2.val,null,null]` 4. **处理叶子节点**： - 弹出`null`直接跳过 - 弹出`2.val`加入结果 → `result=[2]` 5. **处理右子树**： - 弹出`3`，压入`3.val`、`3.right`、`3.left` → `stack=[1.val,3.val,null,null]` - 最终得到结果`2 → 3 → 1` --- #### 关键差异对比 | 方法 | 优势 | 缺点 | 适用场景 | |--------------|---------------------|------------------------|-------------------| | 双栈法 | 代码简洁，易理解 | 需要额外空间存储反向序列 | 树结构简单时 | | 标记法 | 空间复杂度更低 | 类型转换增加复杂度 | 需要优化空间时 | --- #### 复杂度分析 - **时间复杂度**：$O(n)$，每个节点被访问两次（入栈和出栈） - **空间复杂度**：$O(h)$，$h$为树的高度，最坏情况下退化为$O(n)$ --- #### 相关问题 1. 为什么后序遍历的非递归实现比先序/中序更难？ 2. 如何用非递归方法实现二叉树的层次遍历？ 3. 后序遍历在哪些算法中有重要应用？[^3] [^1]: 前序/中序/后序非递归实现差异分析 : 中序遍历非递归实现参考 [^3]: 二叉树遍历的拓展应用场景
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值