Minimum Distance Between BST Nodes - Practice Coding Problems

Minimum Distance Between BST Nodes - Problem

Given the root of a Binary Search Tree (BST), find the minimum absolute difference between the values of any two different nodes in the tree.

A Binary Search Tree guarantees that for every node, all values in the left subtree are smaller and all values in the right subtree are larger. This property can be leveraged to solve the problem efficiently!

Goal: Return the smallest possible difference between any two node values.

Example: In a BST with values [4, 2, 6, 1, 3], the minimum difference would be 1 (between nodes 2 and 3, or 2 and 1).

Input & Output

example_1.py — Basic BST

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

› Output: 1

💡 Note: The minimum difference is between nodes 1 and 2, or 2 and 3, or 3 and 4, all giving a difference of 1.

example_2.py — Larger differences

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

› Output: 1

💡 Note: The minimum difference is between nodes 48 and 49, giving a difference of 1.

example_3.py — Two-node tree

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

› Output: 2

💡 Note: Only two nodes exist: 1 and 3, so the minimum (and only) difference is 2.

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

BST Structure

Left subtree < root < right subtree for every node

Inorder Sequence

Left → Root → Right visits nodes in ascending order

Adjacent Minimum

In sorted sequence, minimum difference is always between adjacent elements

Key Takeaway

🎯 Key Insight: BST inorder traversal produces a sorted sequence, so we only need to compare adjacent values to find the minimum difference!

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 15 f Meta 12

The optimal approach uses one-pass inorder traversal with O(n) time and O(h) space complexity. Since BST inorder traversal produces values in sorted order, the minimum difference must occur between consecutive nodes in this sequence. We track the previous node value during traversal and update the minimum difference on-the-fly.

Common Approaches

Approach	Time	Space	Notes
✓ Inorder Traversal + Sorted Array	O(n)	O(n)	Use inorder traversal to get sorted values, then find minimum difference between adjacent elements
One-Pass Inorder (Optimal)	O(n)	O(h)	Perform inorder traversal and track minimum difference during traversal

Inorder Traversal + Sorted Array — Algorithm Steps

Perform inorder traversal to collect values in sorted order
Iterate through the sorted array
Compare each adjacent pair of elements
Return the minimum difference found

Visualization

Tap to expand

Step-by-Step Walkthrough

Inorder Traversal

Visit nodes in left-root-right order

Collect Sorted Values

Values are automatically in ascending order

Compare Adjacent

Minimum difference must be between adjacent values

Code -

solution.c — C

void inorder(struct TreeNode* node, int* values, int* count) {
    if (!node) return;
    inorder(node->left, values, count);
    values[(*count)++] = node->val;
    inorder(node->right, values, count);
}

int minDiffInBST(struct TreeNode* root) {
    int values[1000];
    int count = 0;
    
    inorder(root, values, &count);
    
    int minDiff = INT_MAX;
    for (int i = 1; i < count; i++) {
        if (values[i] - values[i-1] < minDiff) {
            minDiff = values[i] - values[i-1];
        }
    }
    
    return minDiff;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single inorder traversal O(n) plus single pass through array O(n)

✓ Linear Growth

Space Complexity

O(n)

Array to store all n values plus recursion stack space O(h)

⚡ Linearithmic Space

38.2K Views

Medium Frequency

~15 min Avg. Time

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

Inorder Traversal + Sorted Array — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler