問題描述

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],

return its bottom-up level order traversal as:
[
[15,7],
[9,20],
[3]
]

補充說明：

給定一個二叉樹，遍歷這個樹，然后給出從下到上節點的值。

方案分析

1. 又一個二叉樹的操作，這道題目一看就讓人想到了層次遍歷。與層次遍歷唯一的區別是從下到上遍歷。
2. 先實現層次遍歷的從上到下遍歷，翻轉列表就達到目標了。
3. 這里筆者提供的代碼并未翻轉列表，而是用到了deque，其實一樣的道理。
4. 層次遍歷的核心原理：

• 先將根節點加入一個隊列中
• 判斷這個隊列是否為空，如果不為空，則從隊列左側彈出一個節點，將這個節點的值加入結果列表中。
• 如果這個節點擁有左孩子，則將左孩子從右側加入隊列中，同理，如果這個節點擁有右孩子，則將右孩子加入隊列中。
• 重復上面2-3步驟，直到隊列中不存在元素。
• 得到的結果就是層次遍歷的結果。

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 not root:
            return []

        from collections import deque

        result = deque()
        queue = deque([root])
        while(queue):
            level=[]
            for i in range(len(queue)):
                front=queue.popleft()
                level.append(front.val)
                if front.left:
                    queue.append(front.left)
                if front.right:
                    queue.append(front.right)
            result.appendleft(level)
        return list(result)

方案分析2

1. 看到這個問題，很容易想到二叉樹搜索的兩個基本算法——深度優先算法和廣度優先算法。

python實現2

# 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):
    # dfs recursively
    def levelOrderBottom1(self, root):
        res = []
        self.dfs(root, 0, res)
        return res

    def dfs(self, root, level, res):
        if root:
            if len(res) < level + 1:
                res.insert(0, [])
            res[-(level+1)].append(root.val)
            self.dfs(root.left, level+1, res)
            self.dfs(root.right, level+1, res)
            
    # dfs + stack
    def levelOrderBottom2(self, root):
        stack = [(root, 0)]
        res = []
        while stack:
            node, level = stack.pop()
            if node:
                if len(res) < level+1:
                    res.insert(0, [])
                res[-(level+1)].append(node.val)
                stack.append((node.right, level+1))
                stack.append((node.left, level+1))
        return res
    
    # bfs + queue   
    def levelOrderBottom(self, root):
        queue, res = collections.deque([(root, 0)]), []
        while queue:
            node, level = queue.popleft()
            if node:
                if len(res) < level+1:
                    res.insert(0, [])
                res[-(level+1)].append(node.val)
                queue.append((node.left, level+1))
                queue.append((node.right, level+1))
        return res