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

本文通过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

在这里插入图片描述

<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、付费专栏及课程。

余额充值