Binary Tree Level Order Traversal II

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,#,#,15,7}

,

3
/ \
9  20
/  \
15   7

return its bottom-up level order traversal as:

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

confused what

"{1,#,2,3}"

means?

思路： level travel, DFS, 插入的时候，插在前面，而且get list的时候，注意要用lists.size()-1-level.

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> lists = new ArrayList<List<Integer>>();
        if(root == null) return lists;
        helper(root, lists, 0);
        return lists;
    }
     
    public void helper(TreeNode root, List<List<Integer>> lists, int level){
        if(root == null) return;
        if(level == lists.size()){
            List<Integer> list = new ArrayList<Integer>();
            list.add(root.val);
            lists.add(0,list);
        } else {
            List<Integer> list = lists.get(lists.size()-1 - level);
            list.add(root.val);
        }
         
        if(root.left!=null){
            helper(root.left, lists, level+1);
        }
        if(root.right!=null){
            helper(root.right, lists, level+1);
        }
    }
}

BFS版本：插入的结果的时候，插入在前面即可。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> lists = new ArrayList<List<Integer>>();
        if(root == null) return lists;
         
        Queue<TreeNode> parent = new LinkedList<TreeNode>();
        Queue<TreeNode> current = new LinkedList<TreeNode>();
        parent.add(root);
     
        while(parent.size()!=0){
            current = parent;
            parent = new LinkedList<TreeNode>();
            List<Integer> list = new ArrayList<Integer>();
            while(current.size()!=0){
                TreeNode node = current.poll();
                list.add(node.val);
                 
                if(node.left!=null){
                    parent.add(node.left);
                }
                if(node.right!=null){
                    parent.add(node.right);
                }
            }
            lists.add(0,list);
        }
        return lists;
    }
}