Binary Tree Tilt

class Solution:
    def findTilt(self, root: Optional[TreeNode]) -> int:
        total_tilt = 0

        def subtree_sum(node):
            nonlocal total_tilt
            if not node:
                return 0
            left = subtree_sum(node.left)
            right = subtree_sum(node.right)
            total_tilt += abs(left - right)
            return node.val + left + right

        subtree_sum(root)
        return total_tilt

class Solution {
public:
    int findTilt(TreeNode* root) {
        totalTilt = 0;
        subtreeSum(root);
        return totalTilt;
    }

private:
    int totalTilt;

    int subtreeSum(TreeNode* node) {
        if (!node) {
            return 0;
        }
        int left = subtreeSum(node->left);
        int right = subtreeSum(node->right);
        totalTilt += abs(left - right);
        return node->val + left + right;
    }
};

function findTilt(root: TreeNode | null): number {
    let totalTilt = 0;

    const subtreeSum = (node: TreeNode | null): number => {
        if (!node) {
            return 0;
        }
        const left = subtreeSum(node.left);
        const right = subtreeSum(node.right);
        totalTilt += Math.abs(left - right);
        return node.val + left + right;
    };

    subtreeSum(root);
    return totalTilt;
}