golang 解法, 执行用时: 0 ms, 内存消耗: 2 MB, 提交时间: 2023-10-16 21:48:14

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func findLeaves(root *TreeNode) [][]int {
    if root == nil {
        return nil
    }

    res := make([][]int,0)
    var traverse func(root *TreeNode) int
    traverse = func(root *TreeNode) int{
        if root == nil {
            return 0
        }
        lh := traverse(root.Left)
        rh := traverse(root.Right)

        h := max(lh,rh)
        if len(res) <= h {
            res = append(res, make([]int,0))
        }
        res[h] = append(res[h], root.Val)
        return h+1
    }
    traverse(root)
    return res
}

func max(a, b int) int { if a < b { return b }; return a }

python3 解法, 执行用时: 44 ms, 内存消耗: 16 MB, 提交时间: 2023-10-16 21:47:18

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right

class Solution:
    def findLeaves(self, root: TreeNode) -> List[List[int]]:
        # 自底向上递归
        def dfs(root):
            if not root:return 0
            l,r=dfs(root.left),dfs(root.right)
            depth=max(l,r)+1
            res[depth].append(root.val)
            return depth

        res=collections.defaultdict(list)
        dfs(root)
        return [v for v in res.values()]

java 解法, 执行用时: 0 ms, 内存消耗: 40.2 MB, 提交时间: 2023-10-16 21:46:57

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<List<Integer>> findLeaves(TreeNode root) {
        List<List<Integer>> resList = new ArrayList<>();
        while(root != null){
            List list = new ArrayList<>();
            root = recur(root, list);
            resList.add(list);
        }
        return resList;
    }
    private TreeNode recur(TreeNode root, List<Integer> list){
        if(root == null){
            return null;
        }
        if(root.left == null && root.right == null){
            list.add(root.val);
            return null;
        }
        root.left = recur(root.left, list);
        root.right = recur(root.right, list);
        return root;
    }
}

cpp 解法, 执行用时: 0 ms, 内存消耗: 9 MB, 提交时间: 2023-10-16 21:46:36

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> findLeaves(TreeNode* root) {
        dfs(root);
        return res;
    }

    int dfs(TreeNode* node) {
        if (!node) return -1;

        // 左
        int left = dfs(node->left);
        // 右
        int right = dfs(node->right);
        // 本结点
        int curr = max(left, right) + 1;
        if (curr >= res.size()) res.push_back({});
        res[curr].push_back(node->val);
        return curr;
    }

private:
    vector<vector<int>> res;
};