Find Mode in Binary Search Tree

class Solution:
    def findMode(self, root: Optional[TreeNode]) -> List[int]:
        counts = {}

        def dfs(node):
            if not node:
                return
            counts[node.val] = counts.get(node.val, 0) + 1
            dfs(node.left)
            dfs(node.right)

        dfs(root)
        max_count = max(counts.values())
        return [value for value, count in counts.items() if count == max_count]

class Solution {
public:
    vector<int> findMode(TreeNode* root) {
        unordered_map<int, int> counts;
        dfs(root, counts);

        int maxCount = 0;
        for (const auto& [value, count] : counts) {
            maxCount = max(maxCount, count);
        }

        vector<int> result;
        for (const auto& [value, count] : counts) {
            if (count == maxCount) {
                result.push_back(value);
            }
        }
        return result;
    }

private:
    void dfs(TreeNode* node, unordered_map<int, int>& counts) {
        if (!node) {
            return;
        }
        counts[node->val]++;
        dfs(node->left, counts);
        dfs(node->right, counts);
    }
};

function findMode(root: TreeNode | null): number[] {
    const counts = new Map<number, number>();

    const dfs = (node: TreeNode | null): void => {
        if (!node) {
            return;
        }
        counts.set(node.val, (counts.get(node.val) ?? 0) + 1);
        dfs(node.left);
        dfs(node.right);
    };

    dfs(root);
    let maxCount = 0;
    for (const count of counts.values()) {
        maxCount = Math.max(maxCount, count);
    }

    const result: number[] = [];
    for (const [value, count] of counts.entries()) {
        if (count === maxCount) {
            result.push(value);
        }
    }
    return result;
}