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

from collections import deque

"""
面试题32 - III. 从上到下打印二叉树
难度中等
请实现一个函数按照之字形顺序打印二叉树，即第一行按照从左到右的顺序打印，
第二层按照从右到左的顺序打印，第三行再按照从左到右的顺序打印，其他行以此类推。
例如:
给定二叉树: [3,9,20,null,null,15,7],
    3
   / \
  9  20
    /  \
   15   7
返回其层次遍历结果：
[
  [3],
  [20,9],
  [15,7]
]
"""

"""
算法流程：
特例处理：当根节点为空，则返回空列表 [] ；
初始化：  定义结果列表 res = [] ，包含根节点的双边队列 dq = [root]，定义层数level ；
BFS 循环：当队列 dq 为空时跳出；
            1 新建一个临时列表 level_list ，用于存储当前层打印结果；
            2 当前层打印循环： 循环次数为当前层节点数（即队列 dq 长度）；
                1 出队： 队首元素出队，记为 node；
                2 打印： 将 node.val 添加至 level_list 尾部；（方法二：也可以在此处分类：偶数层 -> 队列头部，奇数层 -> 队列尾部）
                3 添加子节点： 若 node 的左（右）子节点不为空，则将左（右）子节点加入队列 dq ；
            3 方法一：将当前层结果 level_list 加入 res：奇数层 -> 正序、偶数层 -> 翻转[::-1]：
返回值： 返回打印结果列表 res 即可。
"""


# Definition for a binary tree node.
class TreeNode(object):
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None


# 方法一：用deque
class Solution(object):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        # 判断空队列
        if not root: return []
        # 实例化一个双边队列dq，并加入root
        dq = deque()
        dq.append(root)
        # 定义结果列表 res， 层级 level
        res = []
        level = 0

        while dq:
            # 定义 level_list 存放每层的节点
            level_list = []
            level += 1
            # 遍历dq中的所有节点
            for _ in range(len(dq)):
                # 取出队首的节点
                node = dq.popleft()
                # 把节点加到队尾
                level_list.append(node.val)
                # 把node的左右节点加入dq
                if node.left: dq.append(node.left)
                if node.right: dq.append(node.right)
            # 判断层级：奇数，则把level_list加到list中；偶数，把level_list翻转加到list中
            if level % 2 == 1:
                res.append(level_list)
            elif level % 2 == 0:
                res.append(level_list[::-1])         # 知识点：列表反转：[::-1]
        return res


# 用例
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.left.left = TreeNode(4)
root.left.right = TreeNode(5)
root.right.right = TreeNode(6)

s = Solution()
print(s.levelOrder(root))

# 用例：输入为空
s = Solution()
print(s.levelOrder([]))

 

# 方法二：
class Solution2(object):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        # 判断空队列
        if not root: return []
        # 实例化一个双边队列dq，并加入root
        dq = deque()
        dq.append(root)
        # 定义结果列表 res， 层级 level
        res = []
        level = 0

        while dq:
            # 定义 level_list 存放每层的节点
            level_list = []
            level += 1
            # 遍历 dq中的所有节点
            for _ in range(len(dq)):
                # 取出队首的节点
                node = dq.popleft()
                # 判断层级：奇数，则把节点加到队尾；偶数，加到队首节点值
                if level % 2 == 1: level_list.append(node.val)
                if level % 2 == 0: level_list.insert(0, node.val)     # 注意：是list
                # 把node的左右节点加入dq
                if node.left: dq.append(node.left)
                if node.right: dq.append(node.right)
            res.append(level_list)
        return res

# 用例省略