二叉树的层序遍历

已于 2022-02-24 20:32:31 修改
阅读量1w 收藏 37
点赞数 6
分类专栏： 算法 文章标签： java leetcode 链表
于 2022-02-16 18:03:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53310322/article/details/122961001
版权

二叉树的层序遍历

1.层序遍历

层序遍历一个二叉树。就是从左到右一层一层的区遍历二叉树。为了实现层序遍历，我们需要借助一个辅助数据结构即队列来实现，队列先进先出，符合一层一层遍历的逻辑，而栈先进后出适合模拟深度优先遍历也就是递归的逻辑。

2.实例

2.1二叉树的层序遍历

在这里插入图片描述

二叉树的层序遍历

思路：
1.创建队列用来存储节点，创建list集合用来存储结果
2.逐层记录结果即可。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> ans = new ArrayList<>();//用来输出结果
        Queue<TreeNode> queue  = new LinkedList<>();//创建一个队列，用来逐层存放

        if(root==null) return ans;

        queue.offer(root);
        while(!queue.isEmpty()){
            List<Integer> list = new ArrayList<>();//用于存放值
            int len = queue.size();
            for(int i=0;i<len;i++){
                TreeNode temp = queue.poll();
                list.add(temp.val);//放进list

                if(temp.left!=null) queue.offer(temp.left);
                if(temp.right!=null) queue.offer(temp.right);

            }
            ans.add(list);
        }
        return ans;

    }
}

2.2 二叉树的层序遍历 II

在这里插入图片描述
二叉树的层序遍历 II

思路：
和上题基本一致，只需要在输出结果之前将结果反转即可。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> ans = new ArrayList<>();//用来输出结果
        Queue<TreeNode> queue  = new LinkedList<>();//创建一个队列，用来逐层存放

        if(root==null) return ans;

        queue.offer(root);
        while(!queue.isEmpty()){
            List<Integer> list = new ArrayList<>();//用于存放值
            int len = queue.size();
            for(int i=0;i<len;i++){
                TreeNode temp = queue.poll();
                list.add(temp.val);//放进list

                if(temp.left!=null) queue.offer(temp.left);
                if(temp.right!=null) queue.offer(temp.right);

            }
            ans.add(list);
        }
        //将ans反转即可
        List<List<Integer>> ans1 = new ArrayList<>();
        for(int i=ans.size()-1;i>=0;i--){
            ans1.add(ans.get(i));
        }
        return ans1;
        
        
    }
}

2.3 二叉树的右视图

在这里插入图片描述
二叉树的右视图

和模板思路一致，只不过添加的是队列的最后一个元素
if(i==len-1){//保证当前的最后后子节点
ans.add(temp.val);
}

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> ans = new ArrayList<>();//用来输出结果
        Queue<TreeNode> queue = new LinkedList<>();//队列用来存放节点

        if(root==null) return ans;
        queue.offer(root);

        while(!queue.isEmpty()){
            int len = queue.size();

            for(int i=0;i<len;i++){
                TreeNode temp = queue.poll();
                if(i==len-1){//保证当前的最后后子节点
                    ans.add(temp.val);
                }
                if(temp.left!=null) queue.offer(temp.left);
                if(temp.right!=null) queue.offer(temp.right);
            }
        }
        return ans;
    }
}

2.4 二叉树的层平均值

在这里插入图片描述
二叉树的层平均值

依旧套用模板，只是在记录每一层的值，并输出即可。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Double> averageOfLevels(TreeNode root) {
        List<Double> ans =new ArrayList<>();//用于输出答案
        Queue<TreeNode> queue = new LinkedList<>();//用于存放节点

        if(root==null) return ans;

        queue.offer(root);//将节点存入队列中

        while(!queue.isEmpty()){
            
            int len = queue.size();
            Double sum = 0.0;

            for(int i = 0;i<len;i++){
                TreeNode temp = queue.poll();
                sum+=temp.val;
                
                if(temp.left!=null) queue.offer(temp.left);
                if(temp.right!=null) queue.offer(temp.right);

            }
            ans.add(sum/len);
        }
        return ans;
    }
}

2.5 N叉树的层序遍历

在这里插入图片描述
N叉树的层序遍历

本题我们需要注意的是如何添加孩子节点。

/*
// Definition for a Node.
class Node {
    public int val;
    public List<Node> children;

    public Node() {}

    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, List<Node> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
    public List<List<Integer>> levelOrder(Node root) {
        List<List<Integer>> ans = new ArrayList<>();//用于输出答案
        Queue<Node>  queue = new LinkedList<>();//用于存储节点

        if(root==null) return ans;
        queue.offer(root);//将节点存入队列中

        while(!queue.isEmpty()){
            int len = queue.size();
            List<Integer> list = new ArrayList<>();//记录每层的值

            for(int i=0;i<len;i++){
                Node temp = queue.poll();
                list.add(temp.val);

                 List<Node> children = temp.children;//记录temp的孩子节点
                 if(children==null||children.size()==0) continue;
                    for(Node child:children){
                        if(child!=null){//如果孩子节点不为空
                            queue.offer(child);//添加到队列
                        }
                    }


            }
            ans.add(list);
        }
        return ans;

    }
}

2.6在每个树行中找最大值

在这里插入图片描述
在每个树行中找最大值

注意注意Collection.max()这一方法，输出集合中的最大值

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> largestValues(TreeNode root) {
        List<Integer> ans = new ArrayList<>();//用于输出答案
        Queue<TreeNode> queue = new LinkedList<>();//用于存放节点

        if(root==null) return ans;
        queue.offer(root);//存放当前节点

        while(!queue.isEmpty()){
            int len = queue.size();
            List<Integer> list = new ArrayList<>();//用于记录每一层的值
            for(int i=0;i<len;i++){
                TreeNode temp = queue.poll();//暂时存放节点
                list.add(temp.val);//记录没层的所有值
                if(temp.left!=null) queue.offer(temp.left);
                if(temp.right!=null) queue.offer(temp.right);
            }
            ans.add(Collections.max(list));//注意Collection.max()
        }
        return ans;
    }
}

2.7二叉树的最大深度

在这里插入图片描述

二叉树的最大深度

遍历完每一层时深度加一即可。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int maxDepth(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();//存放节点
        int depth=0;
        if(root==null) return depth;
        
        queue.offer(root);//将节点入队

        while(!queue.isEmpty()){
            int len = queue.size();

            for(int i=0;i<len;i++){
                TreeNode temp = queue.poll();
                if(temp.left!=null) queue.offer(temp.left);
                if(temp.right!=null) queue.offer(temp.right);
                
            }
            depth++;//层数加一
        }
        return depth;
    }
}

2.8二叉树的最小深度

在这里插入图片描述
二叉树的最小深度

只需要找出左右节点都为null的节点，返回当前深度即可。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int minDepth(TreeNode root) {
        List<Integer> ans = new ArrayList<>();
        Queue<TreeNode> queue = new LinkedList<>();

        if(root==null) return 0;
        queue.offer(root);//根节点入队
        int depth=0; 

        while(!queue.isEmpty()){
            depth++;//每进入一层，depth++
            int len = queue.size();
            for(int i=0;i<len;i++){
                TreeNode temp = queue.poll();
                //找到叶子节点
                if(temp.left==null&&temp.right==null) return depth;

                if(temp.left!=null) queue.offer(temp.left);
                if(temp.right!=null) queue.offer(temp.right);
            }
        }
        return depth;

    }
}

2.9翻转二叉树

在这里插入图片描述
反转二叉树

思路：使用层序遍历，然后将该层的左右子树翻转即可。


```java
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    /*
    * 层序遍历
    */
    public TreeNode invertTree(TreeNode root) {
        Queue<TreeNode> queue =new LinkedList<>();
        if(root==null) return null;
        
        queue.offer(root);//根节点入队

        while(!queue.isEmpty()){
            int len = queue.size();

            for(int i=0;i<len;i++){
                TreeNode temp=queue.poll();//取出当前根节点
                swapChild(temp);//交换根节点的左右子节点
                
                //继续收集下一层的节点
                if(temp.left!=null) queue.offer(temp.left);
                if(temp.right!=null) queue.offer(temp.right);
            }
        }
        return root;
    }


    //交换根节点的左右子节点
    private void swapChild(TreeNode root){
        TreeNode temp = root.left;
        root.left=root.right;
        root.right=temp;
    }
}

2.10完全二叉树的节点个数

在这里插入图片描述

完全二叉树的节点个数

依旧使用层序遍历，定义一个计数器记录节点个数即可

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int countNodes(TreeNode root) {
        if(root==null) return 0;
        Queue<TreeNode> queue = new LinkedList<>();//存储节点
       
        int num =0;//记录节点个数

        queue.offer(root);

        while(!queue.isEmpty()){
            int len = queue.size();

            for(int i=0;i<len;i++){
                TreeNode temp = queue.poll();//出队
                num++;
                
                if(temp.left!=null) queue.offer(temp.left);
                if(temp.right!=null) queue.offer(temp.right);
            }
        }
        return num;
    }
}

2.11左叶子之和

在这里插入图片描述

左叶子之和

本题依旧可以使用层序遍历，解题的关键是如何找到左叶子节点的

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int sumOfLeftLeaves(TreeNode root) {
        if(root==null) return 0;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        int sum=0;

        while(!queue.isEmpty()){
            TreeNode temp=queue.poll();
            //注意左叶子的判断
            if(temp.left!=null&&temp.left.left==null&&temp.left.right==null){
                sum+=temp.left.val;
            }
            if(temp.left!=null) queue.offer(temp.left);
            if(temp.right!=null) queue.offer(temp.right);
        }
        return sum;

    }
}

2.11找树左下角的值

在这里插入图片描述
找树左下角的值

注意int的使用，只有一个值

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
 
class Solution {
    /**
    注意只有一个值，所有用int
     */
    public int findBottomLeftValue(TreeNode root) {
        int ans=0;
        Queue<TreeNode> queue =new LinkedList<>();//放节点
        queue.offer(root);

        while(!queue.isEmpty()){
            int len =queue.size();
            for(int i=0;i<len;i++){
                TreeNode temp = queue.poll();//取出当前节点
                if(i==0) ans = temp.val;
                if(temp.left!=null) queue.offer(temp.left);
                if(temp.right!=null)  queue.offer(temp.right);
            }

        }
        return ans;

    }
}
奇怪的玩家aaa
关注
  • 6
    点赞
  • 踩
  • 37
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树层序遍历.zip
02-07
二叉树层序遍历是一种常见的树形数据结构操作，主要应用于解决各种问题，例如查找树的宽度、构建树的镜像或者找到树的最大深度等。在这个“二叉树层序遍历.zip”资源中，我们可以期待深入学习二叉树的层序遍历算法...
【数据结构】二叉树的层序遍历(BFS)
Colorful___的博客
10-06 7591
层序遍历是一种广度优先搜索的遍历方式，适用于树结构。通过利用队列实现层序遍历，我们可以按照从上到下、从左到右的顺序逐层遍历树中的节点。层序遍历广泛应用于树的分析、最短路径寻找、二叉树的构建等场景。掌握层序遍历的原理和实现方法将对解决相关问题非常有帮助。
嵌入式0基础开始学习 Ⅱ 数据结构（5）树
最新发布
qq_63137715的博客
05-25 987
树结构是一种非线性结构，在这种结构中一个数据元素可以有两个或以上的直接后继元素。一般用来描述客观世界中存在的层次结构关系。树是N (N >= 0)个结点的有限集。在任意一个非空树中有且只有一个特定的结点称之为根结点(root)当N > 1时， 其余结点可分m个(m > 0)个互不相交的有限集其中每个有限集本身又是一颗树，并称之为根的子树。
二叉树层序遍历
努力进大厂的小码娄
07-10 4435
二叉树的层序遍历，带详细图解。【LeetCode】判断一颗树是否为完全二叉树
数据结构——二叉树层序遍历
mdjsmg的博客
09-20 8393
来喽来喽~ 二叉树的层序遍历来喽~层序遍历那是相当有趣滴！我的朋友，请不要迷惘，你要记住，你终有鲲鹏一日！加油吧！从现在开始~不知道有没有难住你呢！相信你不会被这些小困难绊倒！说给你，更说给我，现在的努力至少不会辜负这一点青春时光！
二叉树层序遍历-实现代码-队列
12-02
/* 设栈元素为二叉树的指针类型 */ typedef struct { QElemType *base; int front; /* 头指针,若队列不空,指向队列头元素 */ int rear; /* 尾指针,若队列不空,指向队列尾元素的下一个位置 */ } SqQueue; ...
基于Java的二叉树层序遍历打印实现.docx
06-27
本篇主要讨论基于Java的二叉树层序遍历的实现，分为三种情况： 1. **基本层序遍历（剑指offer32-Ⅰ）**： 这种遍历方法将二叉树的节点值按层顺序存储到一个一维整数数组`int[] res`中。核心思想是利用队列（这里...
二叉树层序遍历.mp4
02-22
二叉树层序遍历.mp4
二叉树 层序遍历 java实现 课程设计
01-18
本次课程设计的重点是二叉树的层序遍历，这是一种遍历二叉树的方法，按照从上至下、从左到右的顺序访问每一层的节点。 层序遍历通常使用队列（Queue）来辅助完成，因为队列具有先进先出（FIFO）的特性，非常适合...
【二叉树 Java】二叉树的层序遍历
liuwanqing233333的博客
10-28 5237
二叉树层序遍历思路解析及Java代码
二叉树遍历——层序遍历
m0_67198282的博客
03-24 1万+
目录 1.什么是层序遍历？ 2.实现思路 3.代码实现 1.什么是层序遍历？ 就是将一颗树按照每一层每一层的方式进行遍历 例如这棵树，进行层序遍历的结果应该是 那么我们该怎样去实现呢？ 2.实现思路 利用队列先进先出的思想去实现 重要思想：一层带一层 我们先把书的根节点入进去，然后每出一次都把它的子节点入队，出子节点时也一样 3.代码实现 因为我们用的是c来实现，所以在实现前请准备好一个队列 队列头文件 #pragma once #incl.
层序遍历？看这一篇就够了！
热门推荐
BNDSllx的博客
01-09 1万+
点关注不迷路 1.树的层序遍历 顾名思义，对于树型结构，层序遍历就是按层从上到下，每层按一定顺序对树的节点进行遍历。我们通过如图所示的二叉树进行说明：对于左边的二叉树，按层划分后可得到右边的分层结构。 如果按照每层从左到右的遍历逻辑，这棵二叉树的层序遍历序列就是 [1,4,2,7,20,5][1, 4, 2, 7, 20, 5][1,4,2,7,20,5]。通过代码如何实现呢？一般地，我们利用队列 queuequeuequeue 作为容器，按照如下逻辑进行遍历： // 0. 声明队列 queue<T
二叉树的层序遍历(BFS)
weixin_45802793的博客
03-29 5893
文章目录二叉树的层序遍历（bfs）思想：BFS:102.二叉树层序遍历题目思路103.二叉树的锯齿形层序遍历题目199.二叉树的右视图题目：代码 二叉树的层序遍历（bfs） 思想： 二叉树的层序遍历主要是运用bfs的思想，进行一层一层的遍历 BFS: 创建队列Queue,然后从当前一层的节点进行取值操作，然后遍历下一层的节点，如此反复进行 102.二叉树层序遍历 题目 思路 class Solution { public List<List<Integer>> levelOrde
七、二叉树（5）：二叉树的层序遍历
努力努力努力
09-11 5929
学会二叉树的层序遍历，可以一口气打完以下十题： 102.二叉树的层序遍历 107.二叉树的层次遍历II 199.二叉树的右视图 637.二叉树的层平均值 429.N叉树的前序遍历 515.在每个树行中找最大值 116.填充每个节点的下一个右侧节点指针 117.填充每个节点的下一个右侧节点指针II 104.二叉树的最大深度 111.二叉树的最小深度 在之前写过这篇文章二叉树：层序遍历登场！(opens new window)，可惜当时只打了5个，还不够，再给我一次机会，我打十个！ ...
前序遍历、中序遍历、后序遍历层序遍历详解附代码（数据结构C语言）
kim的博客
05-10 1万+
由于二叉树是递归定义的，显然，可以把二叉树遍历操作设计成递归算法。 从二叉树的定义可知，一棵二叉树由三部分组成:根结点，左子树和右子树。若规定D、L、R分别代表“访问根结点”、“遍历根结点的左子树”和“遍历根结点的右子树”，则共有6种组合:LDR、DLR、LRD、RDL、DRL和RLD,由于先遍历左子树和先遍历右子树在算法设计上没有本质区别，因此我们只讨论6种组合的前三种:DLR、LDR和LRD,根据遍历方法对访问根结点处理的位置不同，称这三种遍历方法分别为前序遍历(DLR)、中序遍历(L...
Python二叉树层序遍历
05-14
Python中实现二叉树层序遍历可以使用队列来实现。具体过程如下： 1. 首先，将根节点入队。 2. 在每个循环中，取出队列的头部元素，并将其值存入结果列表中。 3. 如果该节点存在左子树，将其左子树入队。 4. 如果该节点存在右子树，将其右子树入队。 5. 重复步骤2-4，直到队列为空。 下面是Python实现二叉树层序遍历的代码： ``` class TreeNode: def __init__(self, val=0, left=None, right=None): self.val = val self.left = left self.right = right def levelOrder(root: TreeNode) -> List[List[int]]: if not root: return [] res = [] queue = [root] while queue: level = [] n = len(queue) for i in range(n): node = queue.pop(0) level.append(node.val) if node.left: queue.append(node.left) if node.right: queue.append(node.right) res.append(level) return res ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值