LeetCode 层序遍历合集 (102 / 107 / 199 / 637 / 429 / 515 / 116 / 117 / 104 / 111 / 103)

已于 2022-05-03 10:30:21 修改
阅读量349 收藏 1
点赞数 1
分类专栏： leetcode算法 文章标签： leetcode java
于 2022-04-08 17:55:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Amxrjgcs/article/details/124046730
版权

二叉树层序遍历介绍

首先将每一层的节点放入一个队列中，然后遍历这个队列，同时将遍历到的节点的子节点也加入到队列中，直到队列为空。

基本模版：

void traverse(TreeNode root) {
	if (root == null) return;
	Queue<TreeNode> q = new LinkedList<>();
	q.offer(root);
	
	while (!q.isEmpty()) {
		TreeNode cur = q.poll();
		// 层序遍历位置
		System.out.println(cur.val);
		
		if (cur.left != null) q.offer(cur.left);
        if (cur.right != null) q.offer(cur.right);		
	}
}

如果过程中需要分别得到每一层的各元素，则可改为：

public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
    if (root == null) return res;
    Queue<TreeNode> q = new LinkedList<>();
    q.offer(root);

    while (!q.isEmpty()) {
        int count = q.size(); // 记录当前层节点数

// 对当前行所有元素遍历操作
        for (int i = 0; i < count; i++) {
            TreeNode cur = q.poll();
            // 操作每一层的各个元素
            System.out.println(cur.val);

            if (cur.left != null) q.offer(cur.left);
            if (cur.right != null) q.offer(cur.right);
        }
    }

    return res;
}

102. 二叉树的层序遍历

在这里插入图片描述

思路

层序遍历一个二叉树。就是从左到右一层一层的去遍历二叉树。这种遍历的方式和我们之前讲过的都不太一样。
需要借用一个辅助数据结构即队列来实现，队列先进先出，符合一层一层遍历的逻辑，而是用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。
而这种层序遍历方式就是图论中的广度优先遍历，只不过我们应用在二叉树上。

代码实现(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 List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>(); 
        if (root == null) return res;

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

107. 二叉树的层序遍历Ⅱ

在这里插入图片描述

思路

与层序遍历一致，只不过在最后将结果反转即可

代码实现(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 List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>(); 
        if (root == null) return res;

        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            List<Integer> list = new ArrayList<>();
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                list.add(node.val);
                if (node.left != null) queue.add(node.left);
                if (node.right != null) queue.add(node.right);
            }
            res.add(list);
        }
        Collections.reverse(res);
        return res;
    }
}

199. 二叉树的右视图

在这里插入图片描述

思路

层序遍历，统计每层的最后一个结点即可，即每层循环的最后一个i == size - 1

代码实现(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 List<Integer> rightSideView(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if (root == null) return res;
        
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                if (i == (size - 1)) res.add(node.val);
                if (node.left != null) queue.add(node.left);
                if (node.right != null) queue.add(node.right);
            }
        } 
        return res;
    }
}

637. 二叉树的层平均值

在这里插入图片描述

思路

统计每层结点和，然后用 求出的和 除以 该层节点数，接入结果集即可

代码实现(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 List<Double> averageOfLevels(TreeNode root) {
        List<Double> res = new ArrayList<>();
        if (root == null) return res;

        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            double sum = 0.0;
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                sum += node.val;
                if (node.left != null) queue.add(node.left);
                if (node.right != null) queue.add(node.right);
            }
            res.add(sum / size);
        }
        return res;
    }
}

429. N叉树的层序遍历

在这里插入图片描述

思路

只是将左右结点改为了孩子结点的集合，加入队列时遍历孩子结点集合即可

代码实现(java)

/*
// 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>> res = new ArrayList<>();

        if (root == null) return res;

        Queue<Node> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            List<Integer> list = new ArrayList<>();
            for (int i = 0; i < size; i++) {
                Node node = queue.poll();
                list.add(node.val);
                if (node.children.size() != 0) {
                    for (Node cnode : node.children) {
                        queue.add(cnode);
                    }
                }
            }
            res.add(list);
        }

        return res;
    }
}

515. 在每个树行中找最大值

在这里插入图片描述

思路

在每层循环中，依次比较取最大值即可

代码实现(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 List<Integer> largestValues(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if (root == null) {
            return res;
        }

        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while(!queue.isEmpty()) {
            int size = queue.size();
            int max = Integer.MIN_VALUE;
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                max = Math.max(max, node.val);
                if (node.left != null) queue.add(node.left);
                if (node.right != null) queue.add(node.right);
            }
            res.add(max);
        }
        return res;
    }
}

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

在这里插入图片描述

思路

  1. 在遍历每层时，先取出头结点
  2. 然后再依次遍历头结点后面的结点，通过指针的后移，连接后面各个结点即可

代码实现(java)

/*
// Definition for a Node.
class Node {
    public int val;
    public Node left;
    public Node right;
    public Node next;

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

    public Node(int _val, Node _left, Node _right, Node _next) {
        val = _val;
        left = _left;
        right = _right;
        next = _next;
    }
};
*/

class Solution {
    public Node connect(Node root) {
        if (root == null) return root;
        
        Queue<Node> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            int size = queue.size();

            // 记录本层的头结点, 同时将其左右结点加入
            Node cur = queue.poll();
            if (cur.left != null) queue.add(cur.left);
            if (cur.right != null) queue.add(cur.right);

            // 接着遍历同层的其他结点，然后通过头结点一个一个循环连接起来即可
            // 注意这里从1开始，因为头结点已经被取出,循环时少一个元素
            for (int i = 1; i < size; i++) {
                Node node = queue.poll();
                if (node.left != null) queue.add(node.left);
                if (node.right != null) queue.add(node.right);
                cur.next = node;
                cur = node;
            }
        }
        return root;
    }
}

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

在这里插入图片描述

思路

这题与116题唯一的区别就是不是一颗完美二叉树，但是其实思路和解题方法完全一致

代码实现(java)

/*
// Definition for a Node.
class Node {
    public int val;
    public Node left;
    public Node right;
    public Node next;

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

    public Node(int _val, Node _left, Node _right, Node _next) {
        val = _val;
        left = _left;
        right = _right;
        next = _next;
    }
};
*/

class Solution {
    public Node connect(Node root) {
        if (root == null) return root;
        
        Queue<Node> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            int size = queue.size();

            // 记录本层的头结点, 同时将其左右结点加入
            Node cur = queue.poll();
            if (cur.left != null) queue.add(cur.left);
            if (cur.right != null) queue.add(cur.right);

            // 接着遍历同层的其他结点，然后通过头结点一个一个循环连接起来即可
            // 注意这里从1开始，因为头结点已经被取出,循环时少一个元素
            for (int i = 1; i < size; i++) {
                Node node = queue.poll();
                if (node.left != null) queue.add(node.left);
                if (node.right != null) queue.add(node.right);
                cur.next = node;
                cur = node;
            }
        }
        return root;
    }
}

104. 二叉树的最大深度

在这里插入图片描述

思路

在层序遍历的每层循环中，对一个计数器count进行累加操作，只要层序遍历在进行，说明层数还在增加，最后返回count即可

代码实现(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 int maxDepth(TreeNode root) {
        int count = 0;
        if (root == null) return count;

        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            count++;
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                if (node.left != null) queue.add(node.left);
                if (node.right != null) queue.add(node.right);
            }
        }
        return count;
    }
}

补充一个递归方法
算法会向下找到最深的节点，然后向上返回，每次向上返回一次就深度就+1，最终返回左右子树中的最大深度加上根节点即可

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

111. 二叉树的最小深度

在这里插入图片描述

思路

  1. 在层序遍历过程中，还是对计数器count进行累加
  2. 只要发现右节点的左节点和右节点都为空，则说明该结点为叶子节点，这时直接返回count就是最小深度

代码实现(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 int minDepth(TreeNode root) {
        int count = 0;
        if (root == null) return count;

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

103. 二叉树的锯齿形层序遍历

在这里插入图片描述

思路

本题需要锯齿形层序遍历二叉树(先从左到右，再从右到左，依次循环)
根据题意可知，奇数行从左到右遍历，偶数行从右到左遍历
所以在奇数行正常得到遍历序列加入结果集；而偶数行则要先将遍历序列反转然后再加入结果集

代码实现(java)

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        if (root == null) return res;
        int leave = 0;  // 记录层数，奇数层正向，偶数层逆向
        Queue<TreeNode> q = new LinkedList<>();
        q.offer(root);

        while (!q.isEmpty()) {
            int count = q.size(); // 记录当前层节点数
            List<Integer> temp = new ArrayList<>();
            leave++;

            for (int i = 0; i < count; i++) {
                TreeNode cur = q.poll();
                temp.add(cur.val);

                if (cur.left != null) q.offer(cur.left);
                if (cur.right != null) q.offer(cur.right);
            }

            // 偶数层将列表翻转
            if (leave % 2 == 0) {
                Collections.reverse(temp);
            }

            res.add(temp);
        }

        return res;
    }
}
永远在摸鱼的桃
关注
专栏目录
二叉树的层序遍历/后序遍历（leetcode104二叉树的最大深度、111二叉树的最小深度）（华为OD悄悄话、数组二叉树）
欢迎来到我的博客~
06-29 1648
给定一个二叉树 root ，返回其最大深度。二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。本题可以使用前序（中左右），也可以使用后序遍历（左右中），使用前序求的就是深度，使用后序求的是高度。二叉树节点的深度：指从根节点到该节点的最长简单路径边的条数或者节点数（取决于深度从0开始还是从1开始）二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数或者节点数（取决于高度从0开始还是从1开始）
leetcode [103. 二叉树的锯齿形层序遍历](https://leetcode-cn.com/problems/binary-tree-zigzag-level-order-traversa
yingmu__的博客
03-02 75
leetcode 103. 二叉树的锯齿形层序遍历 给你二叉树的根节点 root ，返回其节点值的 锯齿形层序遍历 。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。 示例 1： 输入：root = [3,9,20,null,null,15,7] 输出：[[3],[20,9],[15,7]] 示例 2： 输入：root = [1] 输出：[[1]] 示例 3： 输入：root = [] 输出：[] 提示： 树中节点数目在范围 [0, 2000
C++数据结构代码——层序前序遍历
10-01
C++数据结构代码——层序前序遍历
LeetCode_103 二叉树的锯齿形层序遍历(二叉树层序遍历总结\分别对每一行操作)
Amxrjgcs的博客
10-22 310
二叉树层序遍历介绍 首先将每一层的节点放入一个队列中，然后遍历这个队列，同时将遍历到的节点的子节点也加入到队列中，直到队列为空。 基本模版： void traverse(TreeNode root) { if (root == null) return; Queue<TreeNode> q = new LinkedList<>(); q.offer(root); while (!q.isEmpty()) { TreeNode cur = q.poll(); //.
层序遍历python
最新发布
weixin_43837522的博客
08-23 402
层序遍历函数返回整个树的每层节点，适合需要图结构的使用场景。右侧视图函数只返回每一层的最后节点，适合特定的可视化或某些搜索需求。两者代码的结构非常相似，但处理的逻辑和目标输出是不同的，具体选择哪个功能取决于你的需求。
102. 二叉树的层序遍历
stdleohao的博客
08-09 216
题目链接 /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode() : val(0), left(nullptr), right(nullptr) {} * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {
leetcode学习笔记——二叉树的层序遍历(102,199,637)
2023好运来的博客
03-14 385
层遍历
树 leetcode 层序遍历
一名路过的小码农啊
02-24 198
637. 二叉树的层平均值 给定一个非空二叉树, 返回一个由每层节点平均值组成的数组. 示例 1: 输入: 3 / \ 9 20 / \ 15 7 输出: [3, 14.5, 11] 解释: 第0层的平均值是 3, 第1层是 14.5, 第2层是 11. 因此返回 [3, 14.5, 11]. 注意： 节点值的范围在32位有符号整数范围内。 ...
leetcode.102/107 二叉树层序遍历
qq_40396568的博客
07-26 983
思路一：bfs宽度优先 class Solution { public List<List<Integer>> levelOrder(TreeNode root) { List<List<Integer>> result = new ArrayList<>(); if(root==null) return result; Queue<TreeNode> q..
二叉树的锯齿形层序遍历（BFS / LeetCode）
weixin_44164489的博客
12-22 118
题目链接 题目描述 给定一个二叉树，返回其节点值的锯齿形层序遍历。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。 例如： 给定二叉树 [3,9,20,null,null,15,7], 3 / \ 9 20 / \ 15 7 返回锯齿形层序遍历如下： [ [3], [20,9], [15,7] ] 思路 队列实现层次遍历最后根据结果下标的奇偶性调整顺序即可。 代码如下： class Solution { public:
【LeetCode】之字形顺序打印二叉树（层序遍历 / 双端队列 / 双栈），清晰推演过程
CV前沿
03-27 1173
一、题目 请实现一个函数按照之字形顺序打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右到左的顺序打印，第三行再按照从左到右的顺序打印，其他行以此类推。 例如: 给定二叉树: [3,9,20,null,null,15,7], 3 / \ 9 20 / \ 15 7 返回其层次遍历结果： [ [3], [20,9], [15,7] ] 二、思路分析 这个题目考察的是二叉树的层序遍历的问题。比起普通的层序遍历，它增加了新的要求：按照之子形的顺序来打印。下面我们分别介绍三
LeetCode- 层次遍历
晚晴小筑
03-20 335
637. Average of Levels in Binary Tree Given a non-empty binary tree, return the average value of the nodes on each level in the form of an array. Example 1: Input: 3 / \ 9 20 / \ ...
剑指 Offer 32 - II. 从上到下打印二叉树 II
zj
09-01 197
剑指 Offer 32 - II. 从上到下打印二叉树 II - 力扣（LeetCode） class Solution { public: vector<vector<int>> levelOrder(TreeNode* root) { vector<vector<int>> res; if(!root) return res; vector<int> tmp; queu
leetcode---层序遍历二叉树
啦~啦~啦~的博客
08-10 1058
层序遍历二叉树 Given a binary tree, return the level order traversal of its nodes’ values. (ie, from left to right, level by level). For example: Given binary tree [3,9,20,null,null,15,7], 3 / \...
层序遍历——LeetCode实战中总结套路
沉迷单车的追风少年
02-28 720
目录 层序遍历模板： LeetCode实战1：面试题32-I从上到下打印二叉树 LeetCode实战2：1161.最大层内元素和 四种常用遍历二叉树算法：前序中序后序和层序遍历：https://blog.csdn.net/qq_41895747/article/details/104552612 层序遍历模板： 创建一个 queue 队列，先将根节点（ root ）入队； 再将 qu...
leetcode--二叉树的层序遍历（迭代法）
navylhjjlh的博客
04-15 1186
leetcode--二叉树的层序遍历（C语言）
Leetcode 二叉树的层序遍历
weixin_42095500的博客
10-06 604
问题定义： 给定一个二叉树，返回其按层次遍历的节点值。 （即逐层地，从左到右访问所有节点）。 例如: 给定二叉树: [3,9,20,null,null,15,7], 3 / \ 9 20 / \ 15 7 返回其层次遍历结果： [ [3], [9,20], [15,7] ]   算法思路： 传统的层序遍历算法，while循环...
LeetCode:107.层次遍历
我的博客有点东西
10-22 515
虽然是简单的题目，但是我觉得挺麻烦了。自己写出了解法，没有任何参考，心里觉得很高兴。 我解法的思路是：先使用深度优先遍历，建一个和二叉树形状相同，但内容不同的树，该树的每一个节点记录了对应节点的层数。 然后使用BFS遍历原树和新建的树，得到每个节点对应的层（因为直接BFS是没法得到每一个节点所在的层数的），使用一个list把遍历的值按照顺序append进去。根据得到对应节点的层，很容易重新...
Leetcode 层序遍历
Zoeyii的博客
06-07 92
level代表每一层的层数，如果找不到就会返回一直返回上一层找左右子叶，直到在需要的层数找到最右边的值。注意的问题：题目中要求average是一个double，所以sum也需要是double。1. 在遍历一层的节点的时候， 要先固定size， 因为que.size是在变化的。跟正常的层序遍历基本相同，使用queue存储之前的节点，存储完左右节点后pop。2）使用vector.insert(position, val);1.依旧层序遍历，但只保存每一层最右边的值。1）可以直接使用reverse。
深度优先与广度优先算法详解：面试通关40讲第27-31节
1. LeetCode上的二叉树层序遍历(binary tree level order traversal)：要求按照从上到下、从左到右的顺序输出每个节点的值，是BFS的经典应用。 2. 最大深度和最小深度问题：涉及查找二叉树的最大深度或最小深度，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值