public List<List<Integer>> findLeaves(TreeNode root) {

    List<List<Integer>> result = new ArrayList<List<Integer>>();

    helper(result, root);

    return result;

}

// traverse the tree bottom-up recursively

private int helper(List<List<Integer>> list, TreeNode root){

    if(root==null)

        return -1;

    int left = helper(list, root.left);

    int right = helper(list, root.right);

    int curr = Math.max(left, right)+1;

    // the first time this code is reached is when curr==0,

    //since the tree is bottom-up processed.

    if(list.size()<=curr){

        list.add(new ArrayList<Integer>());

    }

    list.get(curr).add(root.val);

    return curr;

}　

class Solution(object):

    def findLeaves(self, root):

        """

        :type root: TreeNode

        :rtype: List[List[int]]

        """

        def findLeavesHelper(node, result):

            if not node:

                return -1

            level = 1 + max(findLeavesHelper(node.left, result), \

                            findLeavesHelper(node.right, result))

            if len(result) < level + 1:

                result.append([])

            result[level].append(node.val)

            return level

        result = []

        findLeavesHelper(root, result)

        return result

// Time:  O(n)

// Space: O(h)

/**

 * Definition for a binary tree node.

 * struct TreeNode {

 *     int val;

 *     TreeNode *left;

 *     TreeNode *right;

 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}

 * };

 */

class Solution {

public:

    vector<vector<int>> findLeaves(TreeNode* root) {

        vector<vector<int>> result;

        findLeavesHelper(root, &result);

        return result;

    }

private:

    int findLeavesHelper(TreeNode *node, vector<vector<int>> *result) {

        if (node == nullptr) {

            return -1;

        }

        const int level = 1 + max(findLeavesHelper(node->left, result),

                                  findLeavesHelper(node->right, result));

        if (result->size() < level + 1){

            result->emplace_back();

        }

        (*result)[level].emplace_back(node->val);

        return level;

    }

};