問題描述：

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

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

    3
   / \
  9  20
    /  \
   15   7

返回其自底向上的層次遍歷為：

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

說是簡單題，我可沒覺得怎麼簡單，還是廢了些腦力的。程式碼一看就懂，還是從大神那裡獲得的想法。

這是非遞迴的實現，遞迴的自己沒想出來

 public List<List<Integer>> levelOrderBottom(TreeNode root) {
        LinkedList<List<Integer>> res = new LinkedList<>();
        Queue<TreeNode> q = new LinkedList<>();
        if(root == null){
            return res;
        }
        q.add(root);
        while(!q.isEmpty()){
            int size = q.size();
            List<Integer> list = new ArrayList<>();

            for (int i = 0; i < size ; i++) {
                TreeNode t = q.poll();
                list.add(t.val);
                if(t.left!=null){
                    q.add(t.left);
                }
                if(t.right!=null){
                    q.add(t.right);
                }
            }
             res.addFirst(list);
        }
        return res;
    }
 

又去參考大神的遞迴實現，大神是真厲害啊，啥都給你弄成遞迴的，哈哈，菜還是我菜。

public List<List<Integer>> levelOrderBottom(TreeNode root) {
  	List<List<Integer>> result = new ArrayList<>();
		HashMap<Integer, List<Integer>> map = new HashMap<>();//level VS nodes in this level
		fillMap(map,root,1);
		//int i = map.size();
		for( int i = map.size();i>0;i--) {
			result.add(map.get(i));
		}
		return result;
    }
    private void fillMap(HashMap<Integer, List<Integer>> map, TreeNode node, int level) {
		if(node == null ) {
			return;
		}
		if(map.containsKey(level)) {
			map.get(level).add(node.val);
		}else {
			List<Integer> list= new ArrayList<>(); 
			list.add(node.val);
			map.put(level, list);
		}
		fillMap(map, node.left, level+1);
		fillMap(map, node.right, level+1);
	 }