11道精选经典LeetCode例题让你彻底搞懂二叉树的广度优先遍历

最新推荐文章于 2025-05-07 11:10:49 发布
最新推荐文章于 2025-05-07 11:10:49 发布
阅读量2.5k 收藏 19
点赞数 18
CC 4.0 BY-SA版权
分类专栏： 数据结构与算法 LeetCode 文章标签： leetcode 算法 java 面试 广度搜索
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/wenwenaier/article/details/121717763
本文通过11道LeetCode算法题详细介绍了二叉树的层序遍历及其变种，包括层序遍历的基本实现、从下至上返回每一层节点、右视图、层平均值、n叉树的层数遍历、查找每层最大值、填充相邻节点指针、计算最大深度和最小深度以及翻转二叉树。这些题目展示了广度优先搜索在二叉树问题中的广泛应用。

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

文章目录

相见即是有缘，如果对你有帮助，给博主一个免费的点赞以示鼓励把QAQ

在这里插入图片描述

广度优先搜索是遍历二叉树的一种基本方式，也就是层序遍历一个二叉树。从左到右一层一层的去遍历二叉树，对此我们需要借助数据结构队列来完成，因为队列先进先出的特点符合我们遍历的要求，也会成为我们解题的关键，今天我们用11道经典LeetCode算法题认识二叉树的广度优先搜索

在这里插入图片描述
有上述二叉树，我们利用队列Queue对其进行层序遍历
先使6提前进入队列
6进队列
在这里插入图片描述
第1轮遍历，6出队列，6的两个子节点 4,7进入队列

在这里插入图片描述
第2轮遍历，4出队列，4的1,3节点进队列，7出队列，7的5,8节点进队列

在这里插入图片描述
第3轮遍历 1,3，5,8为叶子结点，依次退出队列

下面我们结合11道题目对层序遍历进行理解

1.二叉树的层序遍历|

题目链接：
在这里插入图片描述

    public List<List<Integer>> resList = new ArrayList<>();
    public List<List<Integer>> levelOrder(TreeNode root) {
//        checkFun02(root,resList);
        checkFun01(root,0);
        return resList;
    }

//BFS，广度优先遍历
    private void checkFun02(TreeNode root, List<List<Integer>> resList) {
        if (root==null){
            return;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);

        while (!queue.isEmpty()){
            int len = queue.size();
            List<Integer> list = new ArrayList<>();

            while (len>0){
                TreeNode poll = queue.poll();
                list.add(poll.val);
                if (poll.left!=null) queue.offer(poll.left);
                if (poll.right!=null) queue.offer(poll.right);
                len--;
            }
            resList.add(list);
        }
    }

    //DFS 深度优先遍历
    private void checkFun01(TreeNode root, int dep) {
        if (root==null){
            return;
        }
        dep++;
        while (resList.size()<dep){
            List<Integer> list = new ArrayList<>();
            resList.add(list);
        }
        resList.get(dep-1).add(root.val);
        if (root.left!=null) checkFun01(root.left,dep);
        if (root.right!=null) checkFun01(root.right,dep);
    }

2.二叉树的层序遍历||

题目链接

在这里插入图片描述

    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> resList = new ArrayList<>();
        if (root==null){
            return resList;
        }

        Queue<TreeNode> queue = new LinkedList();
        queue.add(root);
        while (!queue.isEmpty()){
            int len = queue.size();
            List<Integer> list = new ArrayList<>();
            while (len>0){
                TreeNode poll = queue.poll();
                list.add(poll.val);
                if (poll.left!=null) queue.offer(poll.left);
                if (poll.right!=null) queue.offer(poll.right);
                len--;
            }
            resList.add(list);
        }
        Collections.reverse(resList);
        return resList;
    }

3.二叉树的右视图

题目链接

在这里插入图片描述

注意右视图看到的元素指的不单单是右子树的元素，而是每一层最右侧的元素，这个元素也有可能出现在左子树，所以需要将每一层的最后一个元素加入集合

    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        if (root==null){
            return list;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()){
            int len = queue.size();
            while (len>0){
                TreeNode poll = queue.poll();
                if (len==1){
                    list.add(poll.val);
                }
                if (poll.left!=null) queue.offer(poll.left);
                if (poll.right!=null) queue.offer(poll.right);
                len--;
            }
        }
        return list;
    }

4.二叉树的层平均值

题目链接
在这里插入图片描述

利用层序遍历，记录每一层的数字并计算平均值即可

    public List<Double> averageOfLevels(TreeNode root) {
        List<Double> list = new ArrayList<>();
        if (root==null){
            return list;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()){
            double sum = 0;
            int len = queue.size();
            int temp=len;
            while (len>0){
                TreeNode poll = queue.poll();
                sum+=poll.val;
                len--;
                if (poll.left!=null) queue.offer(poll.left);
                if (poll.right!=null) queue.offer(poll.right);
            }
            list.add(sum/temp);
        }
        return list;
    }

5.n叉树的层数遍历

题目链接
在这里插入图片描述
在这里插入图片描述

    public List<List<Integer>> levelOrder(Node root) {
        List<List<Integer>> resList = new ArrayList<>();
        if (root==null){
            return resList;
        }
        Deque<Node> queue = new LinkedList<>();
        queue.offerLast(root);
        while (!queue.isEmpty()){
            int len = queue.size();
            List<Integer> list = new ArrayList<>();

            for (int i=0;i<len;i++){
                Node poll = queue.pollFirst();
                list.add(poll.val);
                List<Node> children = poll.children;
                if (children==null||children.size()==0){
                    continue;
                }
                for (Node child : children) {
                    if (child!=null){
                        queue.offerLast(child);
                    }
                }
            }
            resList.add(list);
        }
        return resList;
    }

6.在每个树行找最大值

题目链接
在这里插入图片描述
在这里插入图片描述

    public List<Integer> largestValues(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        if (root==null){
            return list;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()){
            int len = queue.size();
            int max = Integer.MIN_VALUE;
            for (int i=0;i<len;i++){
                TreeNode poll = queue.poll();
                if (poll.val>max){
                    max = poll.val;
                }
                if (poll.left!=null) queue.offer(poll.left);
                if (poll.right!=null) queue.offer(poll.right);
            }
            list.add(max);
        }
        return list;
    }

7.填充每个节点的下一个右侧节点指针

题目链接
在这里插入图片描述

        Queue<Node> queue = new LinkedList<>();
        if (root==null){
            return null;
        }
        queue.offer(root);
        while (!queue.isEmpty()){
            int len = queue.size();
            Node nodePre = null;
            Node node;
            for (int i=0;i<len;i++){
                if (i==0){
                    nodePre = queue.poll();
                    node = nodePre;
                }else {
                    node = queue.poll();
                    nodePre.next = node;
                    nodePre = nodePre.next;
                }
                if (node.left!=null) queue.offer(node.left);
                if (node.right!=null) queue.offer(node.right);
            }
        }
        return root;

8.填充每个节点的下一个右侧节点指针||

题目链接

这道题目说是二叉树，但第7题题目说是完整二叉树，其实没有任何差别，一样的代码一样的逻辑一样的味道

    public Node connect2(Node root) {
        Queue<Node> queue = new LinkedList<>();
        if (root==null){
            return null;
        }
        queue.offer(root);
        while (!queue.isEmpty()){
            int len = queue.size();
            //处理第一个节点
            Node top = queue.poll();
            if (top.left!=null) queue.offer(top.left);
            if (top.right!=null) queue.offer(top.right);
            for (int i=1;i<len;i++){
                Node poll = queue.poll();
                if (poll.left!=null) queue.offer(poll.left);
                if (poll.right!=null) queue.offer(poll.right);
                top.next = poll;
                top = top.next;
            }
        }
        return root;
    }

9.二叉树的最大深度

题目链接

广度优先搜索解法：

    public int maxDepth(TreeNode root) {
        int max = 0;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()){
            int len = queue.size();
            for (int i=0;i<len;i++){
                TreeNode poll = queue.poll();
                if (poll.left!=null) queue.offer(poll.left);
                if (poll.right!=null) queue.offer(poll.right);
            }
            max++;
        }
        return max;
    }

深度优先搜索解法：

    public int maxDepth2(TreeNode root){
        if (root==null){
            return 0;
        }
        return Math.max(maxDepth(root.left),maxDepth(root.right))+1;
    }

10.二叉树的最小深度

题目描述

在这里插入图片描述

注意，只有左右节点均为空时才有最小深度

        if (root==null){
            return 0;
        }
        Queue<TreeNode> queue = new LinkedList();
        queue.offer(root);
        int min = 0;
        while (!queue.isEmpty()){
            int len = queue.size();
            min++;
            for (int i=0;i<len;i++){
                TreeNode poll = queue.poll();
                if (poll.left==null&&poll.right==null){
                    return min;
                }else {
                    if (poll.left!=null) queue.offer(poll.left);
                    if (poll.right!=null) queue.offer(poll.right);
                }
            }
        }
        return min;

11.翻转二叉树

题目链接

广度优先遍历

    public TreeNode invertTree(TreeNode root) {
        if (root==null){
            return null;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()){
            int len = queue.size();
            for (int i=0;i<len;i++){
                TreeNode poll = queue.poll();
                    TreeNode temp = poll.left;
                    poll.left = poll.right;
                    poll.right = temp;
                if (poll.left!=null) queue.offer(poll.left);
                if (poll.right!=null) queue.offer(poll.right);
            }
        }
        return root;
    }

附：深度优先遍历解法

可以使用前序遍历（中左右）也可以使用后序遍历（左右中），但是中序遍历不可，因为中序遍历为左中右，先交换左子树的孩子，在交换中间节点时会将左右子树进行交换，再交换右子树时将交换的还是左子树

    public TreeNode invertTree2(TreeNode root) {
        if (root==null){
            return null;
        }
        invertTree2(root.left);
        invertTree2(root.right);
        swap(root);
        return root;
    }

    private void swap(TreeNode root) {
        TreeNode temp = root.left;
        root.left = root.right;
        root.right = temp;
    }

相见即是有缘，如果对你有帮助，给博主一个免费的点赞以示鼓励把QAQ

在这里插入图片描述

二叉树的广度优先遍历（BFS）例题——二叉树打印
weixin_45895370的博客
02-05 1071
题目描述 从上到下打印出二叉树的每个节点，同一层的节点按照从左到右的顺序打印。 算法思路 是一个典型的二叉树广度优先遍历的例子。广度优先经常利用队列的先进先出实现的。 特例处理：当树的根结点为空时，直接返回空列表。 建立一个队列，用于遍历每个父节点。遍历了这个父节点的左节点和右节点之后出队列。 class Solution { public: vector<int> levelOrder(TreeNode* root) { queue<TreeNode*> Q
深度/广度优先遍历LeetCode题目整合
薯饼的博客
08-02 1473
从简单到难开始写起 树部分 104.Maximum Depth of Binary Tree（深度优先） Easy Given a binary tree, find its maximum depth. The maximum depth is the number of nodes along the longest path from the root node down to...
二叉树大总结1_二叉树的各种题(遍历、查找)
12-09
二叉树大总结1_二叉树的各种题(遍历、查找等)，是网上一个不错的学习例子。
二叉树练习题（一） 二叉树的遍历
热门推荐
weixin_41611045的博客
10-19 1万+
例题1：对于上述二叉树，请实现层次遍历、先序遍历、中序遍历和后序遍历 ''' 二叉树的遍历 将以下二叉树分别用先序遍历、中序遍历、后序遍历和层次遍历进行遍历 0 1 2 3 4 5 6 7 8 9 先序遍历：中左右 中序遍历：左中右 后序遍历：左右中 ''' class TreeNode: def __init__(self, x): ...
LeetCode：二叉树的前序遍历
最新发布
D_aniel_的博客
05-07 390
给你二叉树的根节点 root ，返回它节点值的 前序 遍历。
LeetCode：二叉树的遍历方式（13道经典题目）
一起加油~
03-31 3708
二叉树的遍历方式（前序遍历、后序遍历、中序遍历以及层序遍历）以及LeetCode相关题目。
二叉树的遍历及其例题（数据结构学习笔记）
省洗发水钱买书
12-15 5243
文章目录先序、中序、后序遍历递归算法1、先序遍历过程先序遍历算法代码2、中序遍历过程中序遍历算法代码3、后序遍历过程后序遍历算法代码层次遍历算法算法设计思路算法代码算法世界复杂度为 O(n)算法例题例题7-11算法思路解题标程例题7-12算法思路解题标程例题7-13算法思路解题标程例题7-14算法思路算法设计例题7-15算法思路解题标程例题7-16算法思路解题标程例题7-17算法思路队列类型声明解题标程结果图示 二叉树的遍历方式主要有四种：先序遍历、中序遍历、后序遍历和层次遍历。 这里我们用递归算法来讨论
搞定leetcode面试经典150题之二叉树
buyaotutou的博客
12-13 1782
节点一个值（或数据）一个指向左子节点的引用一个指向右子节点的引用根节点：二叉树的第一个节点，也就是最上层的节点。每棵树只有一个根节点。子树：树中的任意节点及其所有后代节点称为该节点的子树。每个节点的左子树和右子树本身也是二叉树。叶子节点：没有子节点的节点称为叶子节点。叶子节点是二叉树的终端节点。深度（Depth）：节点的深度是指该节点从根节点开始的路径长度。根节点的深度为 0。高度（Height）：树的高度是根节点的深度。一个节点的高度是指从该节点到其所有子节点的最大深度。
matt-广度优先遍历和深度优先遍历
pavi的博客
08-04 325
文章目录1 广度优先遍历1.1 概念1.2图解1.3代码2.深度优先遍历2.1概念2.2图解2.3代码3例题3.1分析 1 广度优先遍历 1.1 概念 ①以初始节点V0作为第一层节点,接着访问它。 ②然后迭代第一层节点即V0，访问它相邻接的没有访问过的节点比如V1,V2，V1,V2加入到第二层节点 ③迭代第二层节点V1,V2，V1,V2依次访问相邻接的没有访问过的节点，重复上述步骤直至所有节点都被访问过为止。 1.2图解 如图所示首先访问根节点v0,并将v0加入到第一层。迭代第一层节点，和vo相邻接的没有
leetcode刷题01：二叉树的前序、中序、后序、层次遍历（python实现）
ayangann915的博客
02-26 542
二叉树的前序、中序、后序、层次遍历 本文主要汇总leetcode中涉及到二叉树前、中、后、层次遍历的题目以及对应的思路和解答。 文章目录二叉树的前序、中序、后序、层次遍历144：二叉树的前序遍历递归实现迭代实现94：二叉树的中序遍历递归实现迭代实现145：二叉树的后序遍历递归实现迭代实现102：二叉树的层序遍历107：二叉树的层次遍历II 关于普通的前后中层次遍历： 目前我整理的有递归和迭代两种实现方式（前中后遍历） 递归和迭代两种思路都有套路可言，比如递归实现只需要改变一下代码的位置，而迭代涉及到栈的使用
二叉树经典例题——leetcode
Yangcp_的博客
09-17 426
二叉树
广度优先遍历 实例
08-02
广度优先遍历作为一个初学者必备的技能，此资源免费，广度优先遍历是连通图的一种遍历策略。因为它的思想是从一个顶点V0开始，辐射状地优先遍历其周围较广的区域，故得名
二叉树系列题目（包含 深度，广度，先序，中序，层次遍历）
wrs__lele的博客
08-17 1691
树的深度优先遍历最简单的实现方式是实现。从根节点出发依次遍历根节点的每颗子树，对于子树可以视作一颗新的树采用相同的策略继续往下遍历子树的子树，直到无子树为止。
二叉树的层序遍历习题集锦
韩豆豆小姐的博客
10-22 1912
想说点东西给我自己 啊，鬼知道我这一周到底干了啥；干啥啥不行，吃饭第一名，冬天快要来了，有羽绒服不需要脂肪来御寒，请有点自知之明，微笑脸。要把前几天没做的给补回来 这次就来个二叉树的二层次遍历叭，从二叉树的层次遍历可以延伸出好多题目 层次遍历集锦 1.102. 二叉树的层序遍历 给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。 示例： 二叉树：[3,9,20,null,null,15,7] /** * Definition for a binary tree
二叉树的链式存储
罗小黑の窝
02-24 716
头文件：函数的声明 #include #include #include #define MAXSIZE 100 typedef char ElemType; typedef struct Node { ElemType data; struct Node *lchild; struct Node *rchild; }*BitTree,BitNode; /*二叉树的基本操作*/ vo
二叉树遍历的的例子
Dean_Deng的专栏
08-23 2171
二叉树遍历代码二叉树三种遍历小例子：#include <stdio.h> #include <malloc.h>struct BTNode * CreateBTree(void); void PreTraverseBTree(struct BTNode * pT); void InTraverseBTree(struct BTNode * pT); void PostTraverseBTree(st
广度优先遍历的几个例题
MaxLykoS的博客
06-26 6001
题目来自《啊哈！算法》1.广度优先搜索遍历二维数组迷宫0 0 1 00 0 0 00 0 1 00 1 # 00 0 0 1（下标从1开始，#为终点，左上角为起点）先上代码#include "stdafx.h" #include "iostream" using namespace std; typedef struct Queue { int x; int y; int step; }; ...
二叉树的遍历+基础练习
weixin_53316121的博客
04-14 8652
前面完全二叉树适合存放数据，又因为它在内存中连续存储，因此用顺序表来实现它，并介绍了堆排序及TOP-K问题。 今天我们了解一下二叉树的遍历问题，并完成几道二叉树基础OJ题目。 二叉树的遍历 二叉树的遍历有：前序/中序/后序的递归结构遍历： 1. 前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。 2. 中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之间。 3. 后序遍历(Postorder Trave
遍历二叉树（例题及代码）
gets_s的博客
04-22 3622
一、遍历二叉树 1、遍历方法： 先序遍历（DLR）：根结点、左子树、右子树； 中序遍历（LDR）：左子树、根结点、右子树； 后序遍历（LRD）：左子树、右子树、根结点； 2、给出一个二叉树，试写出其先序、中序、后序遍历 例如： 3、给出先序遍历和中序遍历，可求后序遍历；给出中序遍历和后序遍历，可求出先序遍历；注意：给出先序遍历和后序遍历无法确定唯一的二叉树，故无法确定其中序遍历； 例如： ...
二叉树遍历树形例题及答案
03-30
<think>嗯，用户需要关于二叉树遍历的例题和解答。首先，我得回忆一下常见的二叉树遍历题目，比如前序、中序、后序以及层次遍历。根据引用[3]，里面提到了很多LeetCode题目，比如144、94、145分别是前序、中序、后序遍历，还有层序遍历相关的题目比如102、107。这些题目应该可以作为例题。 接下来，我需要整理每个遍历方式的基本算法，然后给出对应的例题和解答。比如前序遍历可以用递归或者迭代实现，引用[1]提到三种遍历的算法结构相似，只是访问根节点的顺序不同。所以在示例代码中，递归方法调整printf的位置即可。不过用户可能需要更具体的代码，比如Python实现。 然后，层次遍历通常用队列实现，比如题目102，可以用BFS的方法逐层处理节点。这里要确保代码正确，并且有注释说明。引用[3]里提到的层序遍历、右视图、平均值等题目都可以作为例子。 另外，用户可能还想知道如何解决这些题目的思路，比如中序遍历的迭代方法需要用到栈来模拟递归，可能需要详细解释步骤。还有后序遍历的非递归实现比较复杂，可以用反向先序遍历的方法，或者记录访问状态。 在整理答案时，要注意使用中文，数学公式用$...$，独立公式用$$...$$，并确保LaTeX语法正确。同时，每个例题后附上题解和代码，代码块用Python语法高亮。最后生成相关问题，比如不同遍历的应用、非递归实现的方法，或者特定题目的变种问题。 需要检查引用是否正确，比如引用[1]提到三种遍历的搜索路线相同，递归过程相同，这可能用来解释代码结构的相似性。引用[3]提供的题目列表可以用来举例。确保所有信息准确，并且例题解答符合题目要求。</think>### 二叉树遍历算法及典型例题解析 #### 一、二叉树遍历的核心算法 1. **前序遍历**（根左右）： **递归实现**： ```python def preorder(root): if not root: return print(root.val) # 访问根节点 preorder(root.left) # 遍历左子树 preorder(root.right) # 遍历右子树 ``` **非递归实现**（使用栈）： ```python def preorder_iterative(root): stack = [] while stack or root: while root: print(root.val) # 访问根节点 stack.append(root) root = root.left # 深入左子树 root = stack.pop() root = root.right # 转向右子树 ``` 2. **中序遍历**（左根右）： **递归实现**： ```python def inorder(root): if not root: return inorder(root.left) # 遍历左子树 print(root.val) # 访问根节点 inorder(root.right) # 遍历右子树 ``` **非递归实现**： ```python def inorder_iterative(root): stack = [] while stack or root: while root: stack.append(root) root = root.left # 深入左子树 root = stack.pop() print(root.val) # 访问根节点 root = root.right # 转向右子树 ``` 3. **后序遍历**（左右根）： **递归实现**： ```python def postorder(root): if not root: return postorder(root.left) # 遍历左子树 postorder(root.right) # 遍历右子树 print(root.val) # 访问根节点 ``` **非递归实现**（反向先序遍历+反转）： ```python def postorder_iterative(root): stack = [root] result = [] while stack: node = stack.pop() if node: result.append(node.val) stack.append(node.left) # 左子节点先入栈 stack.append(node.right) # 右子节点后入栈 return result[::-1] # 反转得到后序结果 ``` 4. **层序遍历**（广度优先）： ```python from collections import deque def level_order(root): if not root: return [] queue = deque([root]) result = [] while queue: level = [] for _ in range(len(queue)): node = queue.popleft() level.append(node.val) if node.left: queue.append(node.left) if node.right: queue.append(node.right) result.append(level) return result ``` --- #### 二、典型例题及解答 ##### 例题1：二叉树的前序遍历（LeetCode 144） **要求**：返回节点值的前序列表。 **题解**：递归或迭代实现均可。 ```python # 递归解法 class Solution: def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]: res = [] def dfs(node): if not node: return res.append(node.val) dfs(node.left) dfs(node.right) dfs(root) return res ``` ##### 例题2：二叉树的中序遍历（LeetCode 94） **要求**：返回节点值的中序列表。 **题解**： ```python # 迭代解法 class Solution: def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]: res, stack = [], [] while stack or root: while root: stack.append(root) root = root.left root = stack.pop() res.append(root.val) root = root.right return res ``` ##### 例题3：二叉树的层序遍历（LeetCode 102） **要求**：按层输出节点值的二维数组。 **题解**：使用队列实现广度优先搜索。 ```python class Solution: def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]: if not root: return [] res = [] queue = deque([root]) while queue: level = [] for _ in range(len(queue)): node = queue.popleft() level.append(node.val) if node.left: queue.append(node.left) if node.right: queue.append(node.right) res.append(level) return res ``` ##### 例题4：二叉树的右视图（LeetCode 199） **要求**：返回从右侧能看到的节点值列表。 **题解**：层序遍历时记录每层最后一个节点。 ```python class Solution: def rightSideView(self, root: Optional[TreeNode]) -> List[int]: if not root: return [] res = [] queue = deque([root]) while queue: level_size = len(queue) for i in range(level_size): node = queue.popleft() if i == level_size - 1: # 当前层最后一个节点 res.append(node.val) if node.left: queue.append(node.left) if node.right: queue.append(node.right) return res ``` --- #### 三、关键知识点总结 - **遍历差异**：三种递归遍历仅访问根节点的顺序不同，搜索路径完全一致[^1]。 - **时间复杂度**：所有遍历均为$O(n)$，空间复杂度递归为$O(h)$（h为树高），迭代为$O(n)$。 - **应用场景**： - 前序遍历：复制树结构、序列化二叉树。 - 中序遍历：二叉搜索树的有序输出。 - 后序遍历：计算子树性质（如高度）。 - 层序遍历：按层处理节点（如右视图、平均值）。 ---
评论 45
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

温文艾尔

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值