算法刷题打卡第20天：二叉树的层序遍历---递归

二叉树的层序遍历

难度：中等
给你二叉树的根节点 root ，返回其节点值的层序遍历 。 （即逐层地，从左到右访问所有节点）。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]

示例 2：

输入：root = [1]
输出：[[1]]

示例 3：

输入：root = []
输出：[]

递归算法

思路：
遍历每一个节点，如果不为空，则将遍历到的节点值放入列表中，之后再将该节点的左右子节点依次进行递归。写法一中平铺到列表，最后进行对列表处理得到结果，写法二中传入每次所在的层数，放入对应层数的列表，可以直接得到最终结果，是写法一的优化。

时间复杂度： O(n)，其中 n 是二叉搜索树的节点数。每一个节点恰好被遍历一次。
空间复杂度： O(n)，为递归过程中栈的开销，平均情况下为 O(log⁡n)，最坏情况下树呈现链状，为 O(n)。
写法一（写的比较复杂且运行速度较慢）：

class Solution:
    def level(self, root, size, lis):
        if size + 1 > len(lis):
            for i in range(size -len(lis) + 1):
                lis.append(None)
        if root is not None:
            lis[size] = root.val
            self.level(root.left, 2*size, lis)
            self.level(root.right, 2*size+1, lis)

    def result_integration(self, lis):
        new_lis = []
        size = 0
        left = 0
        right = 0
        while right <= len(lis):
            right += pow(2, size)
            new_lis.append([i for i in lis[left+1: right+1] if i is not None])
            left = right
            size += 1
        return [i for i in new_lis if len(i) > 0]

    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        lis = []
        if root is None:
            return lis
        
        self.level(root, 1, lis)
        return self.result_integration(lis)

写法二：

class Solution:
    def level(self, root, size, lis):
        if root is not None:
            if size + 1 > len(lis):
                for i in range(size + 1 - len(lis)):
                    lis.append([])
            lis[size].append(root.val)
            self.level(root.left, size + 1, lis)
            self.level(root.right, size + 1, lis)

    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        lis = []
        self.level(root, 0, lis)
        return lis

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/binary-tree-level-order-traversal