剑指 Offer 32 - I - II - III. 从上到下打印二叉树 （python实现）

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

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

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

[3,9,20,15,7]

提示：

节点总数 <= 1000

解题思路：
1、题目要求的二叉树的 从上至下 打印（即按层打印），又称为二叉树的 广度优先搜索（BFS）。
2、BFS 通常借助 队列 的先入先出特性来实现

算法流程：

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

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

class Solution:
    def levelOrder(self, root: TreeNode) -> List[int]:
        if root is None:
            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]
]

提示：

节点总数 <= 1000
解题思路：

1、按层打印： 题目要求的二叉树的 从上至下 打印（即按层打印），又称为二叉树的 广度优先搜索（BFS）。BFS 通常借助 队列 的先入先出特性来实现。

2、每层打印到一行： 将本层全部节点打印到一行，并将下一层全部节点加入队列，以此类推，即可分为多行打印。

算法流程：

1. 特例处理： 当根节点为空，则返回空列表 [] ；

2. 初始化： 打印结果列表 res = [] ，包含根节点的队列 queue = [root] ；

3. BFS 循环： 当队列 queue 为空时跳出；
   1. 新建一个临时列表 tmp ，用于存储当前层打印结果；
   2. 当前层打印循环： 循环次数为当前层节点数（即队列 queue 长度）；
   1. 出队： 队首元素出队，记为 node；
   2. 打印： 将 node.val 添加至列表 tmp 尾部；
   3. 添加子节点： 若 node 的左（右）子节点不为空，则将左（右）子节点加入队列 queue ；

4. 返回值： 返回打印结果列表 res 即可。

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

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
/
9 20
/
15 7
返回其层次遍历结果：

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

提示：

节点总数 <= 1000
解题思路：
层序遍历 + 双端队列

• 利用双端队列的两端皆可添加元素的特性，设打印列表（双端队列） tmp ，并规定：
  • 奇数层 则添加至 tmp 尾部 ，
  • 偶数层 则添加至 tmp 头部 。

算法流程：

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

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

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