Find Leaves of Binary Tree

Given a binary tree, collect a tree's nodes as if you were doing this: Collect and remove all leaves, repeat until the tree is empty.

Example:
Given binary tree

          1
         / \
        2   3
       / \     
      4   5    

Returns [4, 5, 3], [2], [1].

Explanation:

1. Removing the leaves [4, 5, 3] would result in this tree:

          1
         / 
        2          

2. Now removing the leaf [2] would result in this tree:

          1          

3. Now removing the leaf [1] would result in the empty tree:

          []         

Returns [4, 5, 3], [2], [1].

Credits:
Special thanks to  @elmirap for adding this problem and creating all test cases.

思路：就是一个层级关系；计算每一层的depth，然后往上返回的应该是 Math.max(leftdepth, rightdepth)+1; 如果lists.size()< curdepth，证明需要继续加list；关于顺序，就是先到左边，把lists里面list建立好了，visite到右边的时候，加进去就可以了，这样就是顺序的；

class Solution {
    public List<List<Integer>> findLeaves(TreeNode root) {
        List<List<Integer>> lists = new ArrayList<List<Integer>>();
        dfs(root, lists);
        return lists;
    }
    
    private int dfs(TreeNode root, List<List<Integer>> lists) {
        if(root == null) {
            return 0;
        }
        int depth = 1 + Math.max(dfs(root.left, lists) , dfs(root.right, lists));
        if(lists.size() < depth) {
            lists.add(new ArrayList<Integer>());
        }
        lists.get(depth - 1).add(root.val);
        return depth;
    }
}

class Solution {
    public List<List<Integer>> findLeaves(TreeNode root) {
        List<List<Integer>> lists = new ArrayList<List<Integer>>();
        if(root == null) {
            return lists;
        }
        HashMap<Integer, List<Integer>> hashmap = new HashMap<>();
        dfs(root, hashmap);
        for(Integer key: hashmap.keySet()) {
            lists.add(new ArrayList<Integer>(hashmap.get(key)));
        }
        return lists;
    }
    
    private int dfs(TreeNode root,  HashMap<Integer, List<Integer>> hashmap) {
        if(root == null) {
            return 0;
        }
        if(root.left == null && root.right == null) {
            hashmap.putIfAbsent(1, new ArrayList<Integer>());
            hashmap.get(1).add(root.val);
            return 1;
        }
        int maxdepth = Math.max(dfs(root.left, hashmap), dfs(root.right, hashmap)) + 1;
        hashmap.putIfAbsent(maxdepth, new ArrayList<Integer>());
        hashmap.get(maxdepth).add(root.val);
        return maxdepth;
    }
}