Leetcode 二叉树四种遍历方式总结

最新推荐文章于 2025-04-26 23:36:59 发布
最新推荐文章于 2025-04-26 23:36:59 发布
阅读量957 收藏 4
点赞数
分类专栏： 编程算法 文章标签： Leetcode 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/moonspiritacm/article/details/99715526
版权
本文深入探讨了二叉树的四种主要遍历方法：前序遍历、中序遍历、后序遍历和层序遍历。通过递归和迭代两种实现方式，详细解释了每种遍历的原理和代码实现。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

文章目录

1. 前序遍历

Leetcode 144. 二叉树的前序遍历

递归实现：

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        helper(root, res);
        return res;
    }

    private void helper(TreeNode root, List<Integer> res) {
        if (root == null) {
            return;
        }

        res.add(root.val);
        helper(root.left, res);
        helper(root.right, res);
    }
}

迭代实现：沿左侧分支展开，同时压栈，直到左子树为空；弹出栈顶元素，转向右子树，重复上述步骤，直到栈为空。该方法适用于三种遍历方式。

  1. 将当前节点压入栈中，节点值加入输出序列（前序遍历），跳转到左子树；
  2. 重复过程 1，直到左子树为空；
  3. 弹出栈顶元素，节点值加入输出序列（中序遍历），跳转到右子树；
  4. 重复过程 1，直到栈为空。
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        if (root == null) {
            return new ArrayList<>();
        }

        List<Integer> res = new ArrayList<>();
        Stack<TreeNode> stk = new Stack<>();
        while (true) {
            while (root != null) {
                res.add(root.val);
                stk.push(root);
                root = root.left;
            }
            if (stk.isEmpty()) {
                break;
            }
            TreeNode node = stk.pop();
            root = node.right;
        }
        return res;
    }
}

迭代实现：每次循环，右子节点先入后出，左子节点后入先出，利用栈的特性完成遍历，仅适用于前序遍历。

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        if (root == null) {
            return new ArrayList<>();
        }

        List<Integer> res = new ArrayList<>();
        Stack<TreeNode> stk = new Stack<>();
        stk.push(root);
        while (!stk.isEmpty()) {
            TreeNode node = stk.pop();
            res.add(node.val);
            if (node.right != null) {
                stk.push(node.right);
            }
            if (node.left != null) {
                stk.push(node.left);
            }
        }
        return res;
    }
}

2. 中序遍历

Leetcode 94. 二叉树的中序遍历

递归实现：

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        helper(root, res);
        return res;
    }

    private void helper(TreeNode root, List<Integer> res) {
        if (root == null) {
            return;
        }

        helper(root.left, res);
        res.add(root.val);
        helper(root.right, res);
    }
}

迭代实现：

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        if (root == null) {
            return new ArrayList<>();
        }

        List<Integer> res = new ArrayList<>();
        Stack<TreeNode> stk = new Stack<>();
        while (true) {
            while (root != null) {
                stk.push(root);
                root = root.left;
            }
            if (stk.isEmpty()) {
                break;
            }
            TreeNode node = stk.pop();
            res.add(node.val);
            root = node.right;
        }
        return res;
    }
}

3. 后序遍历

Leetcode 145. 二叉树的后序遍历

递归实现：

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        helper(root, res);
        return res;
    }

    private void helper(TreeNode root, List<Integer> res) {
        if (root == null) {
            return;
        }

        helper(root.left, res);
        helper(root.right, res);
        res.add(root.val);
    }
}

迭代实现：后序遍历就是逆前序遍历的倒序输出，逆前序遍历即先访问根节点，再处理右子树，最后处理左子树。

  • 前序遍历：根 -> 左 -> 右；
  • 逆前序遍历：根 -> 右 -> 左；
  • 后序遍历：左 -> 右 -> 根。
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        if (root == null) {
            return new ArrayList<>();
        }

        List<Integer> res = new ArrayList<>();
        Stack<TreeNode> stk = new Stack<>();
        while (true) {
            while (root != null) {
                res.add(root.val);
                stk.push(root);
                root = root.right;
            }
            if (stk.isEmpty()) {
                break;
            }
            TreeNode node = stk.pop();
            root = node.left;
        }
        Collections.reverse(res);
        return res;
    }
}

迭代实现：后序遍历中，只有遍历完右子树，才能访问根节点。因此，需要引入变量记录上一次访问的节点，用于判断是否完成了对右子树的遍历。

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        if (root == null) {
            return new ArrayList<>();
        }

        List<Integer> res = new ArrayList<>();
        Stack<TreeNode> stk = new Stack<>();
        TreeNode pre = null;
        while (root != null) {
            pre = root;
            stk.push(root);
            root = root.left;
        }
        while (!stk.isEmpty()) {
            TreeNode node = stk.peek();
            if (pre == node.right || node.right == null) {
                pre = stk.pop();
                res.add(node.val);
            } else {
                root = node.right;
                while (root != null) {
                    pre = root;
                    stk.push(root);
                    root = root.left;
                }
            }
        }
        return res;
    }
}

4. 层序遍历

Leetcode 102. 二叉树的层次遍历

递归实现：

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        helper(root, 0, res);
        return res;
    }

    private void helper(TreeNode root, int level, List<List<Integer>> res) {
        if(root == null) {
            return;
        }
        if(level == res.size()) {
            res.add(new ArrayList<>());
        }
        res.get(level).add(root.val);
        helper(root.left, level+1,res);
        helper(root.right,level+1,res);
    }
}

迭代实现：

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        if (root == null) {
            return new ArrayList<>();
        }

        List<List<Integer>> res = new ArrayList<>();
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            int n = queue.size();
            List<Integer> ans = new ArrayList<>();
            for (int i = 0; i < n; i++) {
                TreeNode node = queue.remove();
                ans.add(node.val);
                if (node.left != null) {
                    queue.add(node.left);
                }
                if (node.right != null) {
                    queue.add(node.right);
                }
            }
            res.add(ans);
        }
        return res;
    }
}
二叉树的遍历（七种方法）
Python、C++、HTML、Java
10-23 1万+
本章主要通过运用递归与非递归方法分别对二叉树进行遍历 主要分先序遍历、中序遍历、后序遍历以及层次遍历四种情况进行讨论
leetcode：二叉树的垂直遍历
qq_43776408的博客
06-03 322
前序遍历不能维护从上到下的顺序，所以还需要维护每个节点的深度，利用深度保证上下顺序。相比层序遍历，要更麻烦一些。这样的话你每次取最小值先是9，然后是3，15，然后20，然后7，顺序是对的。递归函数记录每一个节点的垂直值。并不是你往里存值按照先来后到。然后每次取哈希表最小值输出。但问题是哈希表偏偏不这么存。所以这道题建议层序遍历。比如以上面第一个树为例。顺序是对的，不能打乱。但是你忽视了一个问题。你以为的哈希表存的是。
LeetCode 102 ——二叉树的层次遍历
weixin_34124939的博客
11-17 405
1. 题目 2. 解答 定义一个存放树中数据的向量 data，一个存放树的每一层数据的向量 level_data 和一个存放每一层节点的队列 node_queue。 如果根节点非空，根节点进队，然后循环以下过程直至队列为空： 得到队列的大小，即为树中当前层的节点个数。队列元素循环出队，并将节点的值加入 level_data，如果节点有左右子节点，左右子节点入队 将 level_da...
二叉树的遍历（递归和非递归）
最新发布
chenjia0512的博客
04-26 1806
了解二叉树中遍历的方法以及实现，其中包括递归算法和非递归
二叉树前中后序遍历_(非递归)
代码铺子
05-17 438
1. 前序遍历 2. 中序遍历 3. 后序遍历
二叉树的前中后序遍历（非递归）
AwwzJ_0821的博客
02-05 510
要实现前序遍历的非递归方式的思路：先循环遍历左子树，再遍历右子树。具体实现方法：第一次经过结点时就进行输出，但需要进行回溯，所以将经过的结点元素进行入栈。先遍历左子树，当最后一个结点的左孩子都为空时，判断最后一个结点的右子树。在代码中表示就为：遍历左子树时，若当前结点不为空则继续循环，若为空就说明需要判断当前结点的父母结点的右子树了，即需要进行回溯到上一个结点。回溯完成后，继续判断右子树的情况，即从右孩子继续判断：遍历右孩子的左子树，再按照相同方法遍历右孩子的右子树。所以需要两个变量，一个变量。
二叉树前中后序遍历【非递归】
smf12138的博客
08-27 939
本篇文章会对二叉搜索树的非递归版本的前中后序遍历做讲解，并对代码进行实现.
【LeetCode刷题记录】简单篇-94-二叉树的中序遍历
呜呼哈嘿嚯的博客
05-02 791
给定一个二叉树的根节点root，返回它的中序遍历。 在二叉树的遍历中，最常用的两种办法，分别是递归法和迭代法 法一：递归法 遍历二叉树有四种方法，前序遍历，中序遍历，后序遍历和层次遍历。除了层次遍历以外，前三种遍历方法用递归的方式实现的逻辑是相同的，都是①递归左子树，②递归右子树，③输出root三个步骤，区别仅仅在于三个步骤的顺序。 法二：迭代法
LeetCode94二叉树的中序遍历
m0_49844997的博客
12-24 1064
算法特点及适用场景特点利用递归方式实现的二叉树中序遍历算法，代码结构简洁明了，非常符合二叉树这种具有递归结构的数据结构的特点，易于理解和实现。它严格按照中序遍历的规则，能够准确地获取二叉树节点值的中序遍历序列。时间复杂度为 ，在遍历二叉树节点获取中序遍历结果方面具有较好的效率表现，只要二叉树的节点数量在可接受范围内，都能快速地完成遍历操作。适用场景。
LeetCode-按层次遍历二叉树
12-02
LeetCode是一个提供算法面试题目练习的平台，其中包含了许多与二叉树相关的题目，包括层次遍历二叉树的问题。 JavaScript是一种广泛使用的高级编程语言，它以其简洁和强大的功能被广泛应用于网站和服务器端的开发中...
数据结构：二叉树：二叉树的先序、中序、后序遍历（非递归方式）
Sauron7i的博客
04-26 4703
数据结构 二叉树的遍历 迭代方法 栈＋计数方法
[算法] 二叉树的 先序遍历、中序遍历、后序遍历
热门推荐
scxyz的博客
02-27 3万+
本文根据清华大学邓俊辉老师课程《数据结构》总结，课程地址 。 遍历介绍 按照事先约定的某种规则或次序，对节点各访问一次而且仅一次。与向量和列表等线性结构一样，二叉树的这类访问也统称为遍历（traversal）。 二叉树本身并不具有天然的全局次序， 故为实现遍历，需通过在各节点与其孩子之间约定某种局部次序， 间接地定义某种全局次序。 按惯例左兄弟优先于右兄弟， 若记做节点 V ，...
二叉树的先序,中序,后序遍历(非递归算法)
weixin_44203609的博客
09-24 4301
二叉树的非递归前、中、后序遍历算法详解及代码实现（C语言） 1. 前序遍历和中序遍历非递归算法思路 前序和中序非递归遍历的C代码 2. 后序遍历非递归算法思路 后序非递归遍历的C代码 1. 前序遍历和中序遍历非递归算法思路 遍历过程：（如图所示） 图1 前序遍历和中序遍历流程图 从当前节点开始遍历：（当入栈时访问节点内容，则为前序遍历；出栈时访问，则为中序遍历） 1. 若当前节点存在，就存入栈中，并访问左子树； 2. 直到当前节点不存在，就出栈，并通过栈顶节点访问右子树； 3.
二叉树的遍历
qq_50167577的博客
04-14 223
二叉树的遍历: 二叉树的遍历是指按某条搜索路径访问树中每个结点,使得每个结点均被访问一次,而且仅被访问一次. 先序遍历: 若二叉树为空,则什么也不做,否则 访问跟结点 先序遍历左子树 先序遍历右子树 void PreOrder(BiTree T){ if(T!=NULL){ visit(T);//访问根结点 PreOrder(T->lchild);//递归遍历左子树 PreOrder(T->rchild);//递归遍历右子树
leetcode二叉树遍历
ONE_PIECE的专栏
09-01 697
二叉树的遍历主要以根节点为中心展开思路去写，这里先讲下前序遍历非递归，通常的数组二叉树， 都是以标记进行，这里由于是链式二叉树，所以可以通过把每个节点的左右节点指向变为NULL，这样 第二次遍历到就可以通过左右节点进行判断，从而加入结果遍历中： 后序遍历非递归： class Solution { public: vector postorderTraversal(TreeNode
LeetCode 二叉树的遍历
TheAnnoyingDog的博客
08-03 307
二叉树遍历用递归时间很简单，只需要调整递归调用方法的顺序即可。而迭代的方式需要一个栈的结构来辅助完成，需要注意的是入栈和出栈的时机，同时需要记住每经过一个节点，就要将其入栈。...
递归和非递归的方式实现二叉树的先序、中序和后序遍历
LeeWei
10-30 373
import java.util.Stack; /** * Created by lxw, liwei4939@126.com on 2017/10/30. * */ public class PreOrder_InOrder_PosOrder { public class Node{ public int value; public Node
更简单的非递归遍历二叉树
tkp2014的专栏
04-09 2768
解决二叉树的很多问题的方案都是基于对二叉树的遍历。遍历二叉树的前序，中序，后序三大方法算是计算机科班学生必写代码了。其递归遍历是人人都能信手拈来，可是在手生时写出非递归遍历恐非易事。正因为并非易事，所以网上出现无数的介绍二叉树非递归遍历方法的文章。可是大家需要的真是那些非递归遍历代码和讲述吗？代码早在学数据结构时就看懂了，理解了，可为什么我们一而再再而三地忘记非递归遍历方法，却始终记住了递归遍历方
LeetCode---二叉树的层次遍历（2）
qq_37765748的博客
04-14 3290
给定一个二叉树，返回其节点值自底向上的层次遍历。 （即按从叶节点所在层到根节点所在的层，逐层从左向右遍历）例如：给定二叉树 [3,9,20,null,null,15,7], 3 / \ 9 20 / \ 15 7 返回其自自底向上的层次遍历为：[ [15,7], [9,20], [3] ]该题两种做法，一种就是递归，一种使用队列。/** * De...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值