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

于 2021-12-04 16:59:39 发布
阅读量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

在这里插入图片描述

评论 45
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

温文艾尔

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

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

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

打赏作者

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

抵扣说明：

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

余额充值