給定一個二叉樹，返回其節點值自底向上的層序遍歷。 （即按從葉子節點所在層到根節點所在的層，逐層從左向右遍歷）

例如：
給定二叉樹 [3,9,20,null,null,15,7],

3

/
9 20
/
15 7
返回其自底向上的層序遍歷為：

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

來源：力扣（LeetCode）
連結：https://leetcode-cn.com/problems/binary-tree-level-order-traversal-ii

層序遍歷的基礎上，返回結果前將其反轉即可

python

# 0107.二叉樹的層序遍歷II
class Solution:
    def levelOrder(self, root: TreeNode) -> [[int]]:
        """
        迭代法：雙端佇列，每次把單層的節點遍歷出佇列，另外將對應的左右節點加入佇列
        :param root:
        :return:
        """
        results = []
        if not root:
            return results

        from collections import deque
        queue = deque([root]) # 初始化佇列

        while queue:
            size = len(queue) # 遍歷佇列單層長度
            res = [] # 每次遍歷時初始化加入結果集中的列表
            for _ in range(size):
                cur = queue.popleft() # 通過size控制遍歷次數
                res.append(cur.val) # 加入結果集中
                if cur.left: # 添加當前pop節點的左節點進入佇列
                    queue.append(cur.left)
                if cur.right: # 添加當前pop節點的右節點進入佇列
                    queue.append(cur.right)
            results.append(res) # 當層中的所有節點的值放入list中
        results.reverse()
        return results

    def levelOrderRecur(self, root: TreeNode) -> [[int]]:
        """
        遞迴法，
        :param root:
        :return:
        """
        res = []
        def levelOrder(node, index):
            if not node: # 空，返空
                return []
            if len(res) < index: # 開始當前depth
                res.append([])
            res[index-1].append(node.val) # 當前層加入節點值到結果集
            if node.left: # 當前節點有左節點，繼續遞迴，同時層數加1
                levelOrder(node.left, index+1)
            if node.right: # 當前節點有右節點，繼續遞迴，同時層數加1
                levelOrder(node.right, index+1)
        levelOrder(root, 1) # 1層開始遞迴
        res.reverse()
        return res

 

golang

package binaryTree

import "container/list"

// 遞迴遍歷
func levelOrderRecurII(root *TreeNode) [][]int {
	var levelOrder func(node *TreeNode, depth int)
	var res [][]int
	levelOrder = func(node *TreeNode, depth int) {
		if node == nil {
			return
		}
		if len(res) == depth {
			res = append(res, []int{})
		}
		res[depth] = append(res[depth], node.Val)
		if node.Left != nil {
			levelOrder(node.Left, depth+1)
		}
		if node.Right != nil {
			levelOrder(node.Right, depth+1)
		}
	}
	levelOrder(root, 0)
	for i:=0;i<len(res)/2;i++ {
		res[i], res[len(res)-i-1] = res[len(res)-i-1], res[i]
	}
	return res
}

// 迭代遍歷
func levelOrderiterationII(root *TreeNode) [][]int {
	var res =  [][]int{}
	if root == nil { // 空時返回
		return res
	}
	queue := list.New() // 佇列初始化
	queue.PushBack(root)
	var tmpArr []int
	for queue.Len() > 0 {
		length := queue.Len()
		for i:=0;i<length;i++ { // 遍歷當層的節點
			node := queue.Remove(queue.Front()).(*TreeNode) // 當次節點
			if node.Left != nil { // 節點的左節點入隊
				queue.PushBack(node.Left)
			}
			if node.Right != nil { // 節點的右節點入隊
				queue.PushBack(node.Right)
			}
			tmpArr = append(tmpArr, node.Val) // 節點值加入結果集
		}
		res = append(res, tmpArr)
		tmpArr = []int{}
	}
	for i:=0;i<len(res)/2;i++ {
		res[i], res[len(res)-i-1] = res[len(res)-i-1], res[i]
	}
	return res
}