Binary Tree Tilt - Practice Coding Problems

Binary Tree Tilt - Problem

Given the root of a binary tree, calculate the tilt of the entire tree. The tilt of a node is defined as the absolute difference between the sum of all values in its left subtree and the sum of all values in its right subtree.

Key Points:

If a node has no left child, the left subtree sum is 0
If a node has no right child, the right subtree sum is 0
The tree tilt is the sum of all individual node tilts

Example: For a tree with root value 1, left child 2, and right child 3, the tilt of root is |2 - 3| = 1, and the tilts of leaves are |0 - 0| = 0, so total tilt is 1 + 0 + 0 = 1.

Input & Output

example_1.py — Simple Tree

$ Input: [1,2,3]

› Output: 1

💡 Note: Root tilt = |sum([2]) - sum([3])| = |2-3| = 1. Left child tilt = |0-0| = 0. Right child tilt = |0-0| = 0. Total tilt = 1+0+0 = 1.

example_2.py — Complex Tree

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

› Output: 15

💡 Note: Root tilt = |sum([2,3,5]) - sum([9,7])| = |10-16| = 6. Node 2 tilt = |3-5| = 2. Node 9 tilt = |0-7| = 7. Others have tilt 0. Total = 6+2+7+0+0+0 = 15.

example_3.py — Single Node

$ Input: [21]

› Output: 0

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

Visualization

Tap to expand

Understanding the Visualization

Post-order Traversal

Visit children first, then process current node to ensure subtree sums are available

Calculate Subtree Sums

For each node, get sum of left subtree and sum of right subtree from recursive calls

Compute Node Tilt

Tilt = |leftSum - rightSum| measures the imbalance at current node

Accumulate Total

Add current node's tilt to running total and return subtree sum to parent

Key Takeaway

🎯 Key Insight: By using post-order DFS traversal, we calculate each subtree sum exactly once while accumulating tilt values, achieving optimal O(n) time complexity.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once in the tree

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h, O(log n) for balanced tree, O(n) worst case

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [0, 10⁴]
-1000 ≤ Node.val ≤ 1000
Tree can have null children at any level

Asked in

f Facebook 12 a Amazon 8 G Google 6 ⊞ Microsoft 4

The optimal solution uses a single DFS traversal where each node returns its subtree sum while accumulating tilt values. This achieves O(n) time complexity by visiting each node exactly once, compared to the brute force O(n²) approach that recalculates subtree sums repeatedly.

Common Approaches

Approach	Time	Space	Notes
✓ Single-Pass DFS (Optimal)	O(n)	O(h)	Calculate subtree sums and tilts simultaneously in one traversal
Brute Force (Separate Sum Calculations)	O(n²)	O(h)	Calculate subtree sums separately for each node's tilt computation

Single-Pass DFS (Optimal) — Algorithm Steps

Perform a single DFS traversal of the tree
At each node, recursively get sums from left and right subtrees
Calculate current node's tilt as absolute difference of subtree sums
Add current tilt to global tilt accumulator
Return current subtree sum (node.val + leftSum + rightSum) to parent

Visualization

Tap to expand

Step-by-Step Walkthrough

DFS to Leaves

Traverse to leaf nodes first, return their values as subtree sums

Calculate Tilt

At each node, compute tilt from left/right sums and add to total

Return Subtree Sum

Return node.val + leftSum + rightSum to parent

Bubble Up

Each subtree sum is calculated exactly once

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 = malloc(sizeof(struct TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

int totalTilt;

int dfs(struct TreeNode* node) {
    if (!node) return 0;
    
    int leftSum = dfs(node->left);
    int rightSum = dfs(node->right);
    
    // Calculate tilt for current node and add to total
    totalTilt += abs(leftSum - rightSum);
    
    // Return sum of current subtree
    return node->val + leftSum + rightSum;
}

int findTilt(struct TreeNode* root) {
    totalTilt = 0;
    dfs(root);
    return totalTilt;
}

// Simple tree builder for demo
struct TreeNode* buildSampleTree() {
    struct TreeNode* root = createNode(1);
    root->left = createNode(2);
    root->right = createNode(3);
    return root;
}

int main() {
    struct TreeNode* root = buildSampleTree();
    printf("%d\n", findTilt(root));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once in the tree

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h, O(log n) for balanced tree, O(n) worst case

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [0, 10⁴]
-1000 ≤ Node.val ≤ 1000
Tree can have null children at any level

87.4K Views

Medium Frequency

~15 min Avg. Time

2.1K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Single-Pass DFS (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler