从上往下打印二叉树

①

从上往下打印出二叉树的每个节点，同层节点从左至右打印。

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

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    # 返回从上到下每个节点值列表，例：[1,2,3]队列，早进早出
    def PrintFromTopToBottom(self, root):
        # write code here
        l=[]
        if not root:
            return []
        q=[root]
        while len(q):
            t=q.pop(0)
            l.append(t.val)
            
            # l.append(q.pop(0))
            if t.left:
                q.append(t.left)
            if t.right:
                q.append(t.right)
        return l

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

②

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

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

    3
   / \
  9  20
    /  \
   15   7
返回其层次遍历结果：

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

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

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:

        if not root:
            return []

        res=[]
        q=[root]

        while len(q):
            l=[]
            for _ in range(len(q)):
                t=q.pop(0)
                l.append(t.val)
                if t.left:
                    q.append(t.left)
                if t.right:
                    q.append(t.right)
            res.append(l)
        return res
时间复杂度 O(N) ： N为二叉树的节点数量，即 BFS 需循环 N 次。
空间复杂度 O(N) ： 最差情况下，即当树为平衡二叉树时，最多有 N/2 个树节点同时在 queue 中，使用 O(N) 大小的额外空间。

。

③32 - III. 从上到下打印二叉树 III

方法一：层序遍历 + 双端队列
利用双端队列的两端皆可添加元素的特性，设打印列表（双端队列） tmp ，并规定：
奇数层 则添加至 tmp 尾部 ，
偶数层 则添加至 tmp 头部 。
算法流程：
特例处理： 当树的根节点为空，则直接返回空列表 [] ；
初始化： 打印结果空列表 res ，包含根节点的双端队列 deque ；
BFS 循环： 当 deque 为空时跳出；
新建列表 tmp ，用于临时存储当前层打印结果；
当前层打印循环： 循环次数为当前层节点数（即 deque 长度）；
出队： 队首元素出队，记为 node；
打印： 若为奇数层，将 node.val 添加至 tmp 尾部；否则，添加至 tmp 头部；
添加子节点： 若 node 的左（右）子节点不为空，则加入 deque ；
将当前层结果 tmp 转化为 list 并添加入 res ；
返回值： 返回打印结果列表 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=[]
        q=[root]
        num=0
        while len(q):
            l=[]
            for _ in range(len(q)):
                t=q.pop(0)
                if len(res)%2!=0:
                    l.insert(0,t.val)
                else:
                    l.append(t.val)

                

                if t.left:
                    q.append(t.left)
                if t.right:
                    q.append(t.right)
                
            num+=1
            res.append(l)
        return res