Binary Tree Tilt

Binary Tree Tilt - Problem

Given the root of a binary tree, return the sum of every tree node's tilt.

The tilt of a tree node is the absolute difference between the sum of all left subtree node values and all right subtree node values. If a node does not have a left child, then the sum of the left subtree node values is treated as 0. The rule is similar if the node does not have a right child.

Input & Output

Example 1 — Simple Tree

$ Input: root = [1,2,3]

› Output: 1

💡 Note: Node 2: tilt = |0-0| = 0, Node 3: tilt = |0-0| = 0, Node 1: tilt = |2-3| = 1. Total tilt = 0 + 0 + 1 = 1

Example 2 — Larger Tree

$ Input: root = [4,2,9,3,5,null,7]

› Output: 15

💡 Note: Leaf nodes have tilt 0. Node 2: |3-5|=2, Node 9: |0-7|=7, Node 4: |10-16|=6. Total = 2+7+6 = 15

Example 3 — Single Node

$ Input: root = [21]

› Output: 0

💡 Note: Single node has no children, so left sum = 0, right sum = 0, tilt = |0-0| = 0

Constraints

The number of nodes in the tree is in the range [0, 10⁴]
-1000 ≤ Node.val ≤ 1000

Visualization

Tap to expand

Asked in

f Facebook 12 a Amazon 8 M Microsoft 6

The optimal approach uses DFS to calculate subtree sums and accumulate tilts in a single traversal. Each node computes the absolute difference between left and right subtree sums while returning its total subtree sum to the parent. Time: O(n), Space: O(h).

Common Approaches

✓ Brute Force - Separate Sum Calculations

⏱️ Time: O(n²) Space: O(h)

For each node, separately calculate the sum of left subtree and right subtree, then compute tilt. This requires multiple traversals.

Optimal DFS - Single Pass

⏱️ Time: O(n) Space: O(h)

Use DFS to calculate subtree sum and accumulate tilt in a single pass. Each node returns its subtree sum while updating the global tilt.

Brute Force - Separate Sum Calculations — Algorithm Steps

Step 1: For each node, calculate left subtree sum
Step 2: For each node, calculate right subtree sum
Step 3: Compute tilt as absolute difference
Step 4: Sum all tilts

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Left Sum

For each node, traverse left subtree to get sum

Calculate Right Sum

For each node, traverse right subtree to get sum

Compute Tilt

Find absolute difference and add to total

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct TreeNode {
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
};

struct TreeNode* createNode(int val) {
    struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

int sumTree(struct TreeNode* node) {
    if (!node) return 0;
    return node->val + sumTree(node->left) + sumTree(node->right);
}

int calculateTilt(struct TreeNode* node) {
    if (!node) return 0;
    
    int leftSum = sumTree(node->left);
    int rightSum = sumTree(node->right);
    int tilt = abs(leftSum - rightSum);
    
    return tilt + calculateTilt(node->left) + calculateTilt(node->right);
}

int solution(struct TreeNode* root) {
    if (!root) return 0;
    return calculateTilt(root);
}

int main() {
    // For simplicity in C, using a fixed test case
    struct TreeNode* root = createNode(1);
    root->left = createNode(2);
    root->right = createNode(3);
    
    printf("%d\n", solution(root));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes, we traverse its subtree, leading to n×n operations in worst case

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h

✓ Linear Space

125.0K Views

Medium Frequency

~15 min Avg. Time

1.9K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Separate Sum Calculations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler