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 = None

class 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 = None

class 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

一開始並不是很理解爲什麼這個實現會比我的第一種實現更快，思考一下之後發現，第一種實現方法裏面很顯然是有一個循環的。在這個循環中，我們遍歷了一遍父節點，並把子節點都壓進一個數組中，相當於也遍歷了一遍子節點。當我們把這個子節點數組丟進下一次遞歸時，又會再遍歷一次，所以實際上等於所有子節點都遍歷了兩次，所以速度上就慢了很多