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

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

从上到下打印出二叉树的每个节点，同一层的节点按照从左到右的顺序打印。
例如:
给定二叉树: [3,9,20,null,null,15,7]：

返回：

解题思路：

• (BFS) O(n)O(n)
• 我们从根节点开始按宽度优先的顺序遍历整棵树，每次先扩展左子树，再扩展右子树。
• 所以在循环部分是：
  先扩展根节点；
  再依次扩展根节点的左右儿子，也就是从左到右扩展第二层节点；
  再依次从左到右扩展第三层节点；
  依次类推

算法流程：

• 如果根节点不存在则输出[ ]
• 定义列表存放根节点
• 根节点存在则：
  1.输出根节点
  2.向下遍历并把遍历到的节点更新为根节点以循环输出

代码实现：

# 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 []
        result = []
        #定义第一个根节点
        deque = [root]
        #循环根节点：取数、更新根节点
        while deque:
            out = []
            for i in deque:
                result.append(i.val)
            if i.left:
                out.append(i.left)
            if i.right:
                out.append(i.right)
            #更新根节点
            deque = out
        return result

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

从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。
例如:
给定二叉树: [3,9,20,null,null,15,7]

返回其层次遍历结果：

解题思路：
同上，将每层结果用一个临时列表储存起来，并添加到结果result中。

代码实现：

# 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 root is None:return []
        result = []
        deque = [root]
        while deque:
            out = []
            result_tmp = []
            for i in deque:
                result_tmp.append(i.val)
                if i.left:
                    out.append(i.left)
                if i.right:
                    out.append(i.right)  
            #更新节点
            deque = out
            result.append(result_tmp)
        return result

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

请实现一个函数按照之字形顺序打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右到左的顺序打印，第三行再按照从左到右的顺序打印，其他行以此类推。
例如:
给定二叉树: [3,9,20,null,null,15,7]

返回其层次遍历结果：

解题思路：

• 同上，添加一个二叉树层数标记，区分奇偶层数的遍历顺序。

代码实现：

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

class Solution(object):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        if not root:
           return []
        deque = [root]
        result = []
        times = 1
        while deque:
            out = []
            temp = []
            while deque:
                k = deque.pop()
                temp.append(k.val)
                if times % 2:
                    if k.left:
                        out.append(k.left)
                    if k.right:
                        out.append(k.right)
                else:
                    if k.right:
                        out.append(k.right)
                    if k.left:
                        out.append(k.left)
            result.append(temp)
            deque = out
            times += 1
        return result