# 366. 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.

## Solution <a href="#solution" id="solution"></a>

```java
/**
 * 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>> findLeaves(TreeNode root) {
        if (root == null) return new ArrayList<>();
        if (root.left == null && root.right == null) {
            List<Integer> current = new ArrayList<>();
            current.add(root.val);
            List<List<Integer>> result = new ArrayList<>();
            result.add(current);
            return result;
        }

        List<List<Integer>> left = findLeaves(root.left);
        List<List<Integer>> right = findLeaves(root.right);

        if (left.size() < right.size()) {
            List<List<Integer>> temp = right;
            right = left;
            left = temp;
        }

        for (int i = 0; i < right.size(); i++) {
            left.get(i).addAll(right.get(i));
        }

        List<Integer> current = new ArrayList<>();
        current.add(root.val);
        left.add(current);
        return left;
    }

}
```