剑指offer-搜索与回溯算法

最新推荐文章于 2024-07-23 17:36:37 发布

MGonster

最新推荐文章于 2024-07-23 17:36:37 发布

阅读量72

点赞数

分类专栏：剑指offer 文章标签：算法 leetcode python

本文链接：https://blog.csdn.net/huihiu8yuih/article/details/123899341

版权

剑指offer 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

面试题32 - I. 从上到下打印二叉树

从上到下打印出二叉树的每个节点，同一层的节点按照从左到右的顺序打印。

例如:
给定二叉树: [3,9,20,null,null,15,7],

[3,9,20,15,7]

提示：

节点总数 <= 1000

算法流程：

特例处理：当树的根节点为空，则直接返回空列表 [] ；
初始化：打印结果列表 res = [] ，包含根节点的队列 queue = [root] ；
BFS 循环：当队列 queue 为空时跳出；
- 出队：队首元素出队，记为 node；
- 打印：将 node.val 添加至列表 tmp 尾部；
- 添加子节点：若 node 的左（右）子节点不为空，则将左（右）子节点加入队列 queue ；
返回值：返回打印结果列表 res 即可。

复杂度分析：
时间复杂度 O(N)O(N) ： NN 为二叉树的节点数量，即 BFS 需循环 NN 次。
空间复杂度 O(N)O(N) ：最差情况下，即当树为平衡二叉树时，最多有 N/2N/2 个树节点同时在 queue 中，使用 O(N)O(N) 大小的额外空间。

class Solution:
    def levelOrder(self, root: TreeNode) -> List[int]:
        if not root: return []
        res, queue = [], collections.deque()
        queue.append(root)
        while queue:
            node = queue.popleft()
            res.append(node.val)
            if node.left: queue.append(node.left)
            if node.right: queue.append(node.right)
        return res

剑指 Offer 32 - II. 从上到下打印二叉树 II

从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。

例如:
给定二叉树: [3,9,20,null,null,15,7],

返回其层次遍历结果：

[
  [3],
  [9,20],
  [15,7]
]

提示：

节点总数 <= 1000

基本思路

按层打印：题目要求的二叉树的从上至下打印（即按层打印），又称为二叉树的广度优先搜索（BFS）。BFS 通常借助队列的先入先出特性来实现。
每层打印到一行：将本层全部节点打印到一行，并将下一层全部节点加入队列，以此类推，即可分为多行打印。

具体思路：

特例处理：当根节点为空，则返回空列表 [] ；
初始化：打印结果列表 res = [] ，包含根节点的队列 queue = [root] ；
BFS 循环：当队列 queue 为空时跳出；
- 新建一个临时列表 tmp ，用于存储当前层打印结果；
- 当前层打印循环：循环次数为当前层节点数（即队列 queue 长度）；
  - 出队：队首元素出队，记为 node；
  - 打印：将 node.val 添加至 tmp 尾部；
  - 添加子节点：若 node 的左（右）子节点不为空，则将左（右）子节点加入队列 queue ；
- 将当前层结果 tmp 添加入 res 。
返回值： 返回打印结果列表 res 即可。

复杂度分析

时间复杂度 O(N) ： N 为二叉树的节点数量，即 BFS 需循环 N 次。
空间复杂度 O(N) ：最差情况下，即当树为平衡二叉树时，最多有 N/2 个树节点同时在 queue 中，使用 O(N) 大小的额外空间。

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root: return []  # 注意考虑特殊情况
        res, queue = [], collections.deque()
        queue.append(root)
        while queue:
            tmp = []
            for _ in range(len(queue)):
                node = queue.popleft()
                tmp.append(node.val)
                if node.left: queue.append(node.left)
                if node.right: queue.append(node.right)
            res.append(tmp)
        return res

剑指 Offer 32 - III. 从上到下打印二叉树 III

请实现一个函数按照之字形顺序打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右到左的顺序打印，第三行再按照从左到右的顺序打印，其他行以此类推。

例如:
给定二叉树: [3,9,20,null,null,15,7],

返回其层次遍历结果：

[
  [3],
  [20,9],
  [15,7]
]

提示：

节点总数 <= 1000

方法一：层序遍历 + 双端队列

利用双端队列的两端皆可添加元素的特性，设打印列表（双端队列） tmp ，并规定：

奇数层则添加至 tmp 尾部，偶数层则添加至 tmp 头部。

算法流程：

特例处理：当树的根节点为空，则直接返回空列表 [] ；
初始化：打印结果空列表 res ，包含根节点的双端队列 deque ；
BFS 循环：当 deque 为空时跳出；
- 新建列表 tmp ，用于临时存储当前层打印结果；
- 当前层打印循环：循环次数为当前层节点数（即 deque 长度）；
  - 出队：队首元素出队，记为 node；
  - 打印：若为奇数层，将 node.val 添加至 tmp 尾部；否则，添加至 tmp 头部；
  - 添加子节点：若 node 的左（右）子节点不为空，则加入 deque ；
- 将当前层结果 tmp 转化为 list 并添加入 res ；
返回值：返回打印结果列表 res 即可；

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root: return []
        res, deque = [], collections.deque([root])
        while deque:
            tmp = collections.deque()
            for _ in range(len(deque)):
                node = deque.popleft()
                if len(res) % 2: tmp.appendleft(node.val) # 偶数层 -> 队列头部
                else: tmp.append(node.val) # 奇数层 -> 队列尾部
                if node.left: deque.append(node.left)
                if node.right: deque.append(node.right)
            res.append(list(tmp))
        return res

方法二：层序遍历 + 双端队列（奇偶层逻辑分离）
方法一代码简短、容易实现；但需要判断每个节点的所在层奇偶性，即冗余了 N 次判断。
通过将奇偶层逻辑拆分，可以消除冗余的判断。

算法流程：

与方法一对比，仅 BFS 循环不同。

BFS 循环：循环打印奇 / 偶数层，当 deque 为空时跳出；
- 打印奇数层：从左向右打印，先左后右加入下层节点；
- 若 deque 为空，说明向下无偶数层，则跳出；
- 打印偶数层：从右向左打印，先右后左加入下层节点；

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root: return []
        res, deque = [], collections.deque()
        deque.append(root)
        while deque:
            tmp = []
            # 打印奇数层
            for _ in range(len(deque)):
                # 从左向右打印
                node = deque.popleft()
                tmp.append(node.val)
                # 先左后右加入下层节点
                if node.left: deque.append(node.left)
                if node.right: deque.append(node.right)
            res.append(tmp)
            if not deque: break # 若为空则提前跳出
            # 打印偶数层
            tmp = []
            for _ in range(len(deque)):
                # 从右向左打印
                node = deque.pop()
                tmp.append(node.val)
                # 先右后左加入下层节点
                if node.right: deque.appendleft(node.right)
                if node.left: deque.appendleft(node.left)
            res.append(tmp)
        return res

方法三：层序遍历 + 倒序
此方法的优点是只用列表即可，无需其他数据结构。
偶数层倒序：若 res 的长度为奇数，说明当前是偶数层，则对 tmp 执行倒序操作。

复杂度分析：
时间复杂度 O(N) ： N 为二叉树的节点数量，即 BFS 需循环 N 次，占用 O(N) 。共完成少于 N 个节点的倒序操作，占用 O(N) 。
空间复杂度 O(N) ：最差情况下，即当树为满二叉树时，最多有 N/2 个树节点同时在 queue 中，使用O(N) 大小的额外空间。

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root: return []
        res, queue = [], collections.deque()
        queue.append(root)
        while queue:
            tmp = []
            for _ in range(len(queue)):
                node = queue.popleft()
                tmp.append(node.val)
                if node.left: queue.append(node.left)
                if node.right: queue.append(node.right)
            res.append(tmp[::-1] if len(res) % 2 else tmp)
        return res

MGonster

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
剑指offer-搜索与回溯算法

面试题32 - I. 从上到下打印二叉树从上到下打印出二叉树的每个节点，同一层的节点按照从左到右的顺序打印。例如:给定二叉树: [3,9,20,null,null,15,7], 3 / \ 9 20 / \ 15 7返回：[3,9,20,15,7]提示：节点总数 <= 1000算法流程：特例处理：当树的根节点为空，则直接返回空列表 [] ；初始化：打印结果列表 res = [] ，包含根节点的队列 queue = [root]
复制链接

扫一扫