Minimum Absolute Difference in BST - Practice Coding Problems

Minimum Absolute Difference in BST - Problem

You're given the root of a Binary Search Tree (BST) and need to find the smallest possible absolute difference between the values of any two different nodes in the entire tree.

Think of it as finding the two nodes whose values are closest together when you ignore the sign of their difference. For example, if you have nodes with values 2 and 5, the absolute difference is |2-5| = 3.

Goal: Return the minimum absolute difference as an integer.

Input: The root node of a BST

Output: An integer representing the minimum absolute difference

Key Insight: Since this is a BST, an in-order traversal will give you all values in sorted order, making it easier to find consecutive differences!

Input & Output

example_1.py — Basic BST

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

› Output: 1

💡 Note: The tree has values [1,2,3,4,6]. The minimum differences are |2-1|=1, |3-2|=1, and |4-3|=1, so the answer is 1.

example_2.py — Simple BST

$ Input: root = [1,0,48,null,null,12,49]

› Output: 1

💡 Note: The tree contains values [0,1,12,48,49]. The minimum differences are |1-0|=1 and |49-48|=1, so the answer is 1.

example_3.py — Two Node Tree

$ Input: root = [90,69]

› Output: 21

💡 Note: With only two nodes having values 90 and 69, the minimum (and only) absolute difference is |90-69| = 21.

Visualization

Tap to expand

Understanding the Visualization

Start from Leftmost

Begin in-order traversal from the smallest value (leftmost node)

Compare Adjacent

For each subsequent node, compare only with the previously visited node

Track Minimum

Keep updating the minimum difference as you traverse

Complete Traversal

Finish the in-order traversal with the guaranteed minimum difference

Key Takeaway

🎯 Key Insight: BST in-order traversal gives us sorted values, so we only need to check consecutive pairs instead of all possible pairs!

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit each node exactly once during the in-order traversal

✓ Linear Growth

Space Complexity

O(h)

Only recursion stack space needed, where h is the height of the tree (O(log n) for balanced BST, O(n) for skewed tree)

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [2, 10⁴]
0 ≤ Node.val ≤ 10⁵
The tree is guaranteed to be a valid BST

Asked in

G Google 42 a Amazon 38 ⊞ Microsoft 31 f Meta 24

The optimal solution uses a single in-order traversal with O(n) time and O(h) space complexity. Since BST in-order traversal naturally produces sorted values, we only need to compare each node with its immediate predecessor to find the minimum absolute difference. This eliminates the need for storing all values in an array.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass In-Order Traversal (Optimal)	O(n)	O(h)	Track previous node during in-order traversal and compare on the fly
Brute Force (All Pairs Comparison)	O(n²)	O(n)	Compare every node with every other node to find minimum difference
In-Order Traversal + Sorted Array	O(n)	O(n)	Collect values using in-order traversal, then find minimum difference in sorted array

One-Pass In-Order Traversal (Optimal) — Algorithm Steps

Initialize variables to track minimum difference and previous node
Perform in-order traversal (left → root → right)
For each node, compare its value with the previous node's value
Update minimum difference if a smaller difference is found
Update previous node reference and continue traversal

Visualization

Tap to expand

Step-by-Step Walkthrough

Start In-Order

Begin in-order traversal from the leftmost node

Compare with Previous

For each node, compare with the previously visited node

Update Minimum

Update minimum difference if current difference is smaller

Code -

solution.c — C

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

// Definition for a binary tree node
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

static int minDiff;
static struct TreeNode* prevNode;

void inorder(struct TreeNode* node) {
    if (!node) return;
    
    // Traverse left subtree
    inorder(node->left);
    
    // Process current node
    if (prevNode) {
        int diff = node->val - prevNode->val;
        if (diff < minDiff) {
            minDiff = diff;
        }
    }
    prevNode = node;
    
    // Traverse right subtree
    inorder(node->right);
}

int getMinimumDifference(struct TreeNode* root) {
    minDiff = INT_MAX;
    prevNode = NULL;
    inorder(root);
    return minDiff;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit each node exactly once during the in-order traversal

✓ Linear Growth

Space Complexity

O(h)

Only recursion stack space needed, where h is the height of the tree (O(log n) for balanced BST, O(n) for skewed tree)

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [2, 10⁴]
0 ≤ Node.val ≤ 10⁵
The tree is guaranteed to be a valid BST

68.2K Views

Medium Frequency

~15 min Avg. Time

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

One-Pass In-Order Traversal (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler