LeetCode之二叉树层次遍历逆序输出（简单 二叉树）

问题描述：

给定一个二叉树，返回其节点值自底向上的层次遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

例如：
给定二叉树 [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);
	 }