剑指offer-搜索与回溯算法

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

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

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

    3
   / \
  9  20
    /  \
   15   7

返回：

[3,9,20,15,7]

提示：

1. 节点总数 <= 1000

算法流程：

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

复杂度分析：
时间复杂度 O(N) ： N 为二叉树的节点数量，即 BFS 需循环 N 次。
空间复杂度 O(N) ： 最差情况下，即当树为平衡二叉树时，最多有 N/2个树节点同时在 queue 中，使用 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

返回其层次遍历结果：

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

提示：

1. 节点总数 <= 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

难度中等194收藏分享切换为英文接收动态反馈

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

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

    3
   / \
  9  20
    /  \
   15   7

返回其层次遍历结果：

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

提示：

1. 节点总数 <= 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