leetcode.107.Binary Tree Level Order Traversal II

Description

Given a binary tree, return the bottom-up level order traversal of its nodes’ values. (ie, from left to right, level by level from leaf to root).

For example:
Given binary tree [3,9,20,null,null,15,7],

    3   / \  9  20    /  \   15   7

return its bottom-up level order traversal as:

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

sln1

看到题目很直接就想到用广度优先搜索，用递归实现。python代码如下

# Definition for a binary tree node.# class TreeNode(object):#     def __init__(self, x):#         self.val = x#         self.left = None#         self.right = Noneclass Solution(object):    def levelOrderBottom(self, root):        """        :type root: TreeNode        :rtype: List[List[int]]        """        if root == None:            return []        return self.bfs([root])    def bfs(self, nodes):        if len(nodes) == 0:            return []        branch = []        values = []        for node in nodes:            values.append(node.val)            if node.left != None:                branch.append(node.left)            if node.right != None:                branch.append(node.right)        next_layer_values = self.bfs(branch)        next_layer_values.append(values)        return next_layer_values

每一次递归一个循环，分别记录values和branch数组。values数组记录当前层每个节点的val，branch数组记录当前层的所有子节点。接下来调用bfs方法获取到当前层以下的所有层的遍历结果，再把values数组添加进去并返回。思路十分清晰，但是提交后看结果并不是十分理想，同样是python实现，只超过了10%+的提交。

sln2

参考discussion中一个标题为 C++ 4ms solution 的答案，用python简答复现了一次，提交结果尽然比70%+的结果快。python实现如下：

# Definition for a binary tree node.# class TreeNode(object):#     def __init__(self, x):#         self.val = x#         self.left = None#         self.right = Noneclass Solution(object):    def levelOrderBottom(self, root):        """        :type root: TreeNode        :rtype: List[List[int]]        """        if root == None:            return []        depth = self.depth(root)        return self.levelOrder([[] for _ in xrange(depth)], root, depth - 1)    def levelOrder(self, ans, node, depth):        if node is None:            return ans        ans[depth].append(node.val)        ans = self.levelOrder(ans, node.left, depth - 1)        ans = self.levelOrder(ans, node.right, depth - 1)        return ans    def depth(self, node):        if node is None:            return 0        return max(self.depth(node.left), self.depth(node.right)) + 1

一开始并不是很理解为什么这个实现会比我的第一种实现更快，思考一下之后发现，第一种实现方法里面很显然是有一个循环的。在这个循环中，我们遍历了一遍父节点，并把子节点都压进一个数组中，相当于也遍历了一遍子节点。当我们把这个子节点数组丢进下一次递归时，又会再遍历一次，所以实际上等于所有子节点都遍历了两次，所以速度上就慢了很多