Binary Tree Level Order Traversal II

最新推荐文章于 2019-07-03 00:48:33 发布

原创最新推荐文章于 2019-07-03 00:48:33 发布 · 149 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode

刷题专栏收录该内容

28 篇文章

订阅专栏

博客围绕二叉树自底向上层次遍历的题目展开。解题思路包括层次遍历，原代码用queue存当前层节点、temp存下一层节点，存在用多余空间的缺陷，可只用一个queue和两个循环；还可用深度优先遍历，通过depth记录插入链表位置。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目

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

总结

此题首先想到的是用层次遍历，先贴上我的代码：

class Solution:
    def levelOrderBottom(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        if not root:
            return []

        result = [[root.val]]
        queue = [root]
        temp = []

        while True:
            if queue:
                node = queue.pop(0)
                if node.left:
                    temp.append(node.left)
                if node.right:
                    temp.append(node.right)
            else:
                if temp:
                    result.insert(0, [n.val for n in temp])
                    queue += temp
                    temp = []
                else:
                    break

        return result

我的代码看起来比较乱，是用queue保存当前层的节点，temp保存下一层的节点。然后在每次当前层queue读取完后把下一层的所有值[n.val for n in temp]插入在result前面。

分析

代码的缺陷：
用了多余的空间temp，其实可以只用一个queue保存所有数据，是用两个循环，第一个循环用于进入下一层，第二个循环用于遍历当前queue所有的node
参考代码：

public List<List<Integer>> levelOrderBottom(TreeNode root) {

    List<List<Integer>> result = new ArrayList<List<Integer>>();
    if(root==null) return result;
    Queue<TreeNode> q = new LinkedList<>();
    q.add(root);
    while(q.size()>0){
        List<Integer> list = new ArrayList<>();
        int size = q.size();
        for(int i=0; i<size; i++){
            TreeNode node = q.poll();
            list.add(node.val);
            if(node.left!=null) q.add(node.left);
            if(node.right!=null) q.add(node.right);
        }
        result.add(0,list);
    }
    return result;

}

还可以是用深度优先遍历，通过depth记录要插入的链表位置
参考代码：

public class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        List<List<Integer>> wrapList = new LinkedList<List<Integer>>();

        if(root == null) return wrapList;

        queue.offer(root);
        while(!queue.isEmpty()){
            int levelNum = queue.size();
            List<Integer> subList = new LinkedList<Integer>();
            for(int i=0; i<levelNum; i++) {
                if(queue.peek().left != null) queue.offer(queue.peek().left);
                if(queue.peek().right != null) queue.offer(queue.peek().right);
                subList.add(queue.poll().val);
            }
            wrapList.add(0, subList);
        }
        return wrapList;
    }
}