【LeetCode】二叉树的层序遍历——代码随想录算法训练营Day15

最新推荐文章于 2024-05-30 20:15:33 发布
最新推荐文章于 2024-05-30 20:15:33 发布
阅读量1k 收藏 15
点赞数 25
分类专栏： 代码随想录算法训练营 # LeetCode 二叉树 文章标签： 算法 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57521762/article/details/135821410
版权

1. 二叉树的层序遍历（中等）

题目链接：102. 二叉树的层序遍历

文章讲解：代码随想录

视频讲解：讲透二叉树的层序遍历 | 广度优先搜索 | LeetCode：102.二叉树的层序遍历_哔哩哔哩_bilibili

(1) 迭代方式

思路：借助一个队列保存我们遍历过的每一层中的元素。

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number[][]}
 */
var levelOrder = function(root) {
    const res = [];
    const queue = [];
    if (root) {
        queue.push(root);
    }
    while (queue.length > 0) {
        const arr = [];
        // 这里一定要使用固定大小 size，不要使用 queue.length，因为 queue.length 是不断变化的
        let size = queue.length;
        while (size--) {
            const node = queue.shift();
            node.left && queue.push(node.left);
            node.right && queue.push(node.right);
            arr.push(node.val);
        }
        res.push(arr);
    }
    return res;
};

分析：时间复杂度为 O(n)，空间复杂度为 O(n)。

(2) 递归方式

思路：先递归的遍历左子树，将每层节点的值都存入对应层的数组中，再递归的遍历右子树，即可得出层序遍历的结果。

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number[][]}
 */
var levelOrder = function(root) {
    const res = [];
    const order = function (node, depth) {
        if (!node) {
            return;
        }
        if (res.length === depth) {
            res.push([]);
        }
        res[depth].push(node.val); // 将当前节点的值放入结果数组中对应层的数组
        order(node.left, depth + 1); // 递归的遍历左子树
        order(node.right, depth + 1); // 递归的遍历右子树
    }
    order(root, 0);
    return res;
};

分析：时间复杂度为 O(n)，空间复杂度为 O(logn)。

2. 二叉树的层序遍历 II（中等）

题目链接：107. 二叉树的层序遍历 II

思路：和第1题解法相同，区别在于插入到结果数组时从前面插入，即实现了自底向上的层序遍历。

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number[][]}
 */
var levelOrderBottom = function(root) {
    const res = [];
    const queue = [];
    if (root) {
        queue.push(root);
    }
    while (queue.length > 0) {
        const arr = [];
        let size = queue.length;
        while (size--) {
            const node = queue.shift();
            node.left && queue.push(node.left);
            node.right && queue.push(node.right);
            arr.push(node.val);
        }
        res.unshift(arr);
    }
    return res;
};

分析：时间复杂度为 O(n)，空间复杂度为 O(n)。

3. 二叉树的右视图（中等）

题目链接：199. 二叉树的右视图

思路：对二叉树进行层序遍历，遍历过程中将每层最后一个节点值插入结果数组中。

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number[]}
 */
var rightSideView = function(root) {
    const res = [];
    const queue = [];
    if (root) {
        queue.push(root);
    }
    while (queue.length > 0) {
        let size = queue.length;
        while (size--) {
            const node = queue.shift();
            node.left && queue.push(node.left);
            node.right && queue.push(node.right);
            size === 0 && res.push(node.val); // 将每层最后一个节点值插入结果数组中
        }
    }
    return res;
};

分析：时间复杂度为 O(n)，空间复杂度为 O(n)。

4. 二叉树的层平均值（简单）

题目链接：637. 二叉树的层平均值

思路：对二叉树进行层序遍历，遍历过程中计算每层的平均值。

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number[]}
 */
var averageOfLevels = function(root) {
    const res = [];
    const queue = [];
    if (root) {
        queue.push(root);
    }
    while (queue.length > 0) {
        let sum = 0;
        const size = queue.length;
        for (let i = 0; i < size; i++) {
            const node = queue.shift();
            node.left && queue.push(node.left);
            node.right && queue.push(node.right);
            sum += node.val;
        }
        res.push(sum / size);
    }
    return res;
};

分析：时间复杂度为 O(n)，空间复杂度为 O(n)。

5. N 叉树的层序遍历（中等）

题目链接：429. N 叉树的层序遍历

思路：与二叉树的层序遍历类似，借助队列完成 N 叉树的层序遍历。

/**
 * // Definition for a Node.
 * function Node(val,children) {
 *    this.val = val;
 *    this.children = children;
 * };
 */

/**
 * @param {Node|null} root
 * @return {number[][]}
 */
var levelOrder = function(root) {
    const res = [];
    const queue = [];
    if (root) {
        queue.push(root);
    }
    while (queue.length > 0) {
        const arr = [];
        let size = queue.length;
        while (size--) {
            const node = queue.shift();
            node.children.forEach(node => node && queue.push(node));
            arr.push(node.val);
        }
        res.push(arr);
    }
    return res;
};

分析：时间复杂度为 O(n)，空间复杂度为 O(n)。

6. 在每个树行中找最大值（中等）

题目链接：515. 在每个树行中找最大值

思路：对二叉树进行层序遍历，遍历过程中找出每层的最大值。

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number[]}
 */
var largestValues = function(root) {
    const res = [];
    const queue = [];
    if (root) {
        queue.push(root);
    }
    while (queue.length > 0) {
        let max = -Infinity;
        let size = queue.length;
        while (size--) {
            const node = queue.shift();
            node.left && queue.push(node.left);
            node.right && queue.push(node.right);
            max = node.val > max ? node.val : max;
        }
        res.push(max);
    }
    return res;
};

分析：时间复杂度为 O(n)，空间复杂度为 O(n)。

7. 填充每个节点的下一个右侧节点指针（中等）

题目链接：116. 填充每个节点的下一个右侧节点指针

(1) 层序遍历

思路：对二叉树进行层序遍历，为每个节点填充右侧节点指针。

/**
 * // Definition for a Node.
 * function Node(val, left, right, next) {
 *    this.val = val === undefined ? null : val;
 *    this.left = left === undefined ? null : left;
 *    this.right = right === undefined ? null : right;
 *    this.next = next === undefined ? null : next;
 * };
 */

/**
 * @param {Node} root
 * @return {Node}
 */
var connect = function(root) {
    const queue = [];
    if (root) {
        queue.push(root);
    }
    while (queue.length > 0) {
        let size = queue.length;
        let pre = null; // 上一个节点
        while (size--) {
            const node = queue.shift();
            node.left && queue.push(node.left);
            node.right && queue.push(node.right);
            if (pre) {
                pre.next = node; // 将上个节点的 next 指向当前节点
            }
            pre = node; // 更新上个节点
        }
    }
    return root;
};

分析：时间复杂度为 O(n)，空间复杂度为 O(n)。

(2) 利用“完美二叉树”条件

思路：完美二叉树的所有叶子节点都在同一层，每个父节点都有2个子节点。因此可以一层层建立 next 指针，利用上层的 next 指针建立当前层的 next 指针。有如下2种情况：

  • 若当前节点有子节点，将其左孩子的 next 指针指向其右孩子；
  • 若当前节点有子节点且在同一层有下个节点，将其右孩子的 next 指针指向下个节点的左孩子。
/**
 * // Definition for a Node.
 * function Node(val, left, right, next) {
 *    this.val = val === undefined ? null : val;
 *    this.left = left === undefined ? null : left;
 *    this.right = right === undefined ? null : right;
 *    this.next = next === undefined ? null : next;
 * };
 */

/**
 * @param {Node} root
 * @return {Node}
 */
var connect = function(root) {
    if (!root) {
        return null;
    }
    let leftNode = root;
    while (leftNode.left) {
        let cur = leftNode; // 遍历本层
        while (cur) {
            cur.left.next = cur.right; // 将左孩子的 next 指针指向右孩子
            if (cur.next) {
                cur.right.next = cur.next.left; // 将右孩子的 next 指向下个节点的左孩子
            }
            cur = cur.next; // 继续遍历下个节点
        }
        leftNode = leftNode.left; // 继续遍历下一层
    }
    return root;
};

分析：时间复杂度为 O(n)，空间复杂度为 O(1)。

8. 填充每个节点的下一个右侧节点指针 II（中等）

题目链接：117. 填充每个节点的下一个右侧节点指针 II

思路：和第7题的第1种解法一样，虽然这棵树不再是完美二叉树，用第7题的代码还是能解的。

/**
 * // Definition for a Node.
 * function Node(val, left, right, next) {
 *    this.val = val === undefined ? null : val;
 *    this.left = left === undefined ? null : left;
 *    this.right = right === undefined ? null : right;
 *    this.next = next === undefined ? null : next;
 * };
 */

/**
 * @param {Node} root
 * @return {Node}
 */
var connect = function(root) {
    const queue = [];
    if (root) {
        queue.push(root);
    }
    while (queue.length > 0) {
        let size = queue.length;
        let pre = null; // 上一个节点
        while (size--) {
            const node = queue.shift();
            node.left && queue.push(node.left);
            node.right && queue.push(node.right);
            if (pre) {
                pre.next = node; // 将上个节点的 next 指向当前节点
            }
            pre = node; // 更新上个节点
        }
    }
    return root;
};

分析：时间复杂度为 O(n)，空间复杂度为 O(n)。

9. 二叉树的最大深度（简单）

题目链接：104. 二叉树的最大深度

(1) 层序遍历

思路：对二叉树进行层序遍历，记录二叉树的层数，二叉树的层数即为二叉树的最大深度。

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number}
 */
var maxDepth = function(root) {
    const queue = [];
    if (root) {
        queue.push(root);
    }
    let deep = 0;
    while (queue.length > 0) {
        let size = queue.length;
        while (size--) {
            const node = queue.shift();
            node.left && queue.push(node.left);
            node.right && queue.push(node.right);
        }
        deep++;
    }
    return deep;
};

分析：时间复杂度为 O(n)，空间复杂度为 O(n)。

(2) 递归遍历

思路：对二叉树进行递归遍历，二叉树的最大深度即为左子和右子树最大深度大的一方的深度再加1。

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number}
 */
var maxDepth = function(root) {
    if (!root) {
        return 0;
    }
    return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;
};

分析：时间复杂度为 O(n)，空间复杂度为 O(logn)。

10. 二叉树的最小深度

题目链接：111. 二叉树的最小深度

(1) 层序遍历

思路：对二叉树进行层序遍历，记录二叉树的层数，当遇到第1个叶子节点时，这个叶子节点的深度即为二叉树的最小深度。

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number}
 */
var minDepth = function(root) {
    const queue = [];
    if (root) {
        queue.push(root);
    }
    let res = 0;
    while (queue.length > 0) {
        res++;
        let size = queue.length;
        while (size--) {
            const node = queue.shift();
            node.left && queue.push(node.left);
            node.right && queue.push(node.right);
            if (!node.left && !node.right) {
                return res; // 当遇到叶子节点时，直接返回当前计算的高度即为二叉树的最小深度
            }
        }
    }
    return res;
};

分析：时间复杂度为 O(n)，空间复杂度为 O(n)。

(2) 递归遍历

思路：对二叉树进行递归遍历，二叉树的最小深度即为左子和右子树的最小深度小的一方的深度再加1。

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number}
 */
var minDepth = function(root) {
    if (!root) {
        return 0;
    }
    if (root.left && root.right) {
        return Math.min(minDepth(root.left), minDepth(root.right)) + 1;
    }
    if (root.left) {
        return minDepth(root.left) + 1;
    }
    if (root.right) {
        return minDepth(root.right) + 1;
    }
    return 1;
};

分析：时间复杂度为 O(n)，空间复杂度为 O(logn)。

收获

了解了二叉树的层次遍历，可以使用二叉树的层次遍历和递归遍历来解决一些问题。

晴雪月乔
关注
  • 25
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
windhuiyi#leetcode#02-二叉树-广度遍历层序遍历1
07-25
public void helper(TreeNode root, int level){// 当前层没有 list，新建// 取得当前层的 list迭代pub
python-leetcode面试题解之第107题二叉树的层序遍历II.zip
04-29
python python_leetcode面试题解之第107题二叉树的层序遍历II
【LeetCode】二叉树的遍历——代码随想录算法训练营Day14
晴雪月乔的博客
01-23 1261
二叉树的前序遍历，中序遍历和后序遍历
【LeetCode】110. 平衡二叉树（简单）——代码随想录算法训练营Day17
晴雪月乔的博客
01-26 333
【LeetCode】110. 平衡二叉树
【LeetCode】104. 二叉树的最大深度（简单）——代码随想录算法训练营Day16
晴雪月乔的博客
01-25 920
【LeetCode】104. 二叉树的最大深度
【LeetCode】131. 分割回文串（中等）——代码随想录算法训练营Day27
晴雪月乔的博客
02-05 503
【LeetCode】131. 分割回文串
【LeetCode】17. 电话号码的字母组合（中等）——代码随想录算法训练营Day25
晴雪月乔的博客
02-03 519
【LeetCode】17. 电话号码的字母组合
【LeetCode】101. 对称二叉树（简单）——代码随想录算法训练营Day15
晴雪月乔的博客
01-24 357
【LeetCode】101. 对称二叉树
【LeetCode】968. 监控二叉树（困难）——代码随想录算法训练营Day37
晴雪月乔的博客
02-20 377
【LeetCode】968. 监控二叉树
【LeetCode】654. 最大二叉树（中等）——代码随想录算法训练营Day20
晴雪月乔的博客
01-29 750
【LeetCode】654. 最大二叉树
【LeetCode】617. 合并二叉树（简单）——代码随想录算法训练营Day20
晴雪月乔的博客
01-29 490
【LeetCode】617. 合并二叉树
LeetCode 算法题库【94】——二叉树的中序遍历
12-21
二叉树的中序遍历 题目描述： 解题思路： 第一种：递归。又是递归，可以发现很多题都可以用到递归的思路…。二叉树的中序遍历，这里不太了解的可以看看这个博客：二叉树遍历，总结了二叉树的所有遍历情况。这道题所...
算法之二叉树的层序遍历（利用队列实现，需熟练手写）
01-20
0、这是最基本的层序遍历算法，没有leetCode102题难 1、用了Java两种方式，都挺好的，ArrayDeque的性能比LinkedList要强很多（都可以做队列），所以我就都写了一下，传入根结点即可（没有用数组存二叉树） /** * ...
Leecode---347：输出前k个高频元素（使用unordered_map）
qq_41920323的博客
05-30 316
unordered_map实现输出前k个高频元素
算法每日一题（python,2024.05.24) day.6
L613Z的博客
05-27 551
数字比较型可以用双指针法寻找数字相同（或构成其他关系）的俩个数值（或其他类型），涉及到与数值有关的列表问题可以思考到sort()排序方法加以辅助。
Java多线程（04）—— 保证线程安全的方法与线程安全的集合类
最新发布
2201_75456895的博客
05-30 1187
其含义为：CAS(M, A, B);M 表示内存，A 和 B 分别表示一个寄存器；如果 M 的值和 A 的值相同，则把 M 和 B 的值交换，如果不同，则无事发生；因为，因此可以基于 CAS 指令，不进行加锁，来编写线程安全代码；CAS 指令操作经过操作系统，JVM 的层层封装，最后 Java 标准库，提供了一些工具类，其中最主要工具类就是由于原子类内部用的是 CAS 实现，所以性能要比加锁实现高很多；在包下；
算法训练营day41
stmfresher的博客
05-27 390
动态规划理论基础（主要就是确定动态规划的几个步骤）
一千题，No.0037（组个最小数）
2301_76783671的博客
05-29 797
给定数字 0-9 各若干个。你可以以任意顺序排列这些数字，但必须全部使用。目标是使得最后得到的数尽可能小（注意 0 不能做首位）。例如：给定两个 0，两个 1，三个 5，一个 8，我们得到的最小的数就是 10015558。输入在一行中给出 10 个非负整数，顺序表示我们拥有数字 0、数字 1、……整数间用一个空格分隔。10 个数字的总个数不超过 50，且至少拥有 1 个非 0 的数字。现给定数字，请编写程序输出能够组成的最小的数。在一行中输出能够组成的最小的数。
代码随想录算法训练营第二十二天
09-13
第二十二天的算法训练营主要涵盖了Leetcode题目中的三道题目，分别是Leetcode 28 "Find the Index of the First Occurrence in a String"，Leetcode 977 "有序数组的平方"，和Leetcode 209 "长度最小的子数组"。 首先是Leetcode 28题，题目要求在给定的字符串中找到第一个出现的字符的索引。思路是使用双指针来遍历字符串，一个指向字符串的开头，另一个指向字符串的结尾。通过比较两个指针所指向的字符是否相等来判断是否找到了第一个出现的字符。具体实现的代码如下： ```python def findIndex(self, s: str) -> int: left = 0 right = len(s) - 1 while left <= right: if s[left == s[right]: return left left += 1 right -= 1 return -1 ``` 接下来是Leetcode 977题，题目要求对给定的有序数组中的元素进行平方，并按照非递减的顺序返回结果。这里由于数组已经是有序的，所以可以使用双指针的方法来解决问题。一个指针指向数组的开头，另一个指针指向数组的末尾。通过比较两个指针所指向的元素的绝对值的大小来确定哪个元素的平方应该放在结果数组的末尾。具体实现的代码如下： ```python def sortedSquares(self, nums: List[int]) -> List[int]: left = 0 right = len(nums) - 1 ans = [] while left <= right: if abs(nums[left]) >= abs(nums[right]): ans.append(nums[left ** 2) left += 1 else: ans.append(nums[right ** 2) right -= 1 return ans[::-1] ``` 最后是Leetcode 209题，题目要求在给定的数组中找到长度最小的子数组，使得子数组的和大于等于给定的目标值。这里可以使用滑动窗口的方法来解决问题。使用两个指针来表示滑动窗口的左边界和右边界，通过移动指针来调整滑动窗口的大小，使得滑动窗口中的元素的和满足题目要求。具体实现的代码如下： ```python def minSubArrayLen(self, target: int, nums: List[int]) -> int: left = 0 right = 0 ans = float('inf') total = 0 while right < len(nums): total += nums[right] while total >= target: ans = min(ans, right - left + 1) total -= nums[left] left += 1 right += 1 return ans if ans != float('inf') else 0 ``` 以上就是第二十二天的算法训练营的内容。通过这些题目的练习，可以提升对双指针和滑动窗口等算法的理解和应用能力。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

晴雪月乔

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

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

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

打赏作者

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

抵扣说明：

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

余额充值