Minimum Difference Pair in BST

Last Updated : 7 May, 2026

Given a binary search tree of size n > 1, the task is to find the minimum absolute difference between any two nodes.

Examples:

Input:

Output: 10
Explanation: There are no two nodes whose absolute difference is smaller than 10.
Input:

Output: 20
Explanation: There are no two nodes whose absolute difference is smaller than 20.

Table of Content

Using Inorder Traversal (BST Property) – O(n) Time and O(n) Space
Using Inorder Traversal (Without Extra Space) – O(n) Time and O(h) Space

Using Inorder Traversal (BST Property) – O(n) Time and O(n) Space

The idea is to take advantage of the Binary Search Tree property where inorder traversal gives values in sorted order. Once the values are sorted, the minimum absolute difference will always be found between adjacent. So instead of comparing all pairs, we only check consecutive elements, which significantly reduces the time complexity.

Perform inorder traversal to store node values in sorted order
Traverse the sorted list and compute difference between adjacent elements
Track the minimum difference while iterating
Return the minimum difference obtained

C++

#include <bits/stdc++.h>
using namespace std;

class Node {
public:
    int data;
    Node* left;
    Node* right;

    Node(int data)
    {
        this->data = data;
        left = nullptr;
        right = nullptr;
    }
};

// simple inorder traversal to store values
void inorder(vector<int>& inord, Node* root)
{
    if (root == nullptr)
        return;

    inorder(inord, root->left);
    inord.push_back(root->data); 
    inorder(inord, root->right);
}

// function to find minimum absolute difference
int absDiff(Node* root)
{
    vector<int> inord;

    // inorder of BST gives sorted values
    inorder(inord, root);

    int mini = INT_MAX;
    int n = inord.size();

    // since array is sorted, just check adjacent elements
    for (int i = 0; i < n - 1; i++) {
        mini = min(mini, inord[i + 1] - inord[i]);
    }

    return mini;
}

int main()
{
    Node* root = new Node(5);
    root->left = new Node(3);
    root->right = new Node(7);
    root->left->left = new Node(2);
    root->left->right = new Node(4);
    root->right->left = new Node(6);
    root->right->right = new Node(8);
    cout << absDiff(root);
    return 0;
}

Java

import java.util.*;

// class for tree
class Node {
    int data;
    Node left;
    Node right;

    Node(int data)
    {
        this.data = data;
        left = null;
        right = null;
    }
}

class GFG {

    // simple inorder traversal to store values
    static void inorder(List<Integer> inord, Node root)
    {
        if (root == null)
            return;

        inorder(inord, root.left);
        inord.add(root.data); 
        inorder(inord, root.right);
    }

    // function to find minimum absolute difference
    static int absDiff(Node root)
    {
        List<Integer> inord = new ArrayList<>();

        // inorder of BST gives sorted values
        inorder(inord, root);

        int mini = Integer.MAX_VALUE;
        int n = inord.size();

        // since array is sorted, just check adjacent elements
        for (int i = 0; i < n - 1; i++) {
            mini = Math.min(mini, inord.get(i + 1) - inord.get(i));
        }

        return mini;
    }

    public static void main(String[] args)
    {
        Node root = new Node(5);
        root.left = new Node(3);
        root.right = new Node(7);
        root.left.left = new Node(2);
        root.left.right = new Node(4);
        root.right.left = new Node(6);
        root.right.right = new Node(8);
        System.out.println(absDiff(root));
    }
}

Python

# class for tree
class Node:
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None

# simple inorder traversal to store values
def inorder(inord, root):
    if root is None:
        return

    inorder(inord, root.left)
    inord.append(root.data)
    inorder(inord, root.right)

# function to find minimum absolute difference
def absDiff(root):
    inord = []

    # inorder of BST gives sorted values
    inorder(inord, root)

    mini = float('inf')
    n = len(inord)

    # since array is sorted, just check adjacent elements
    for i in range(n - 1):
        mini = min(mini, inord[i + 1] - inord[i])

    return mini


root = Node(5)
root.left = Node(3)
root.right = Node(7)
root.left.left = Node(2)
root.left.right = Node(4)
root.right.left = Node(6)
root.right.right = Node(8)
print(absDiff(root))

C#

using System;
using System.Collections.Generic;

// class for tree
class Node {
    public int data;
    public Node left;
    public Node right;

    public Node(int data)
    {
        this.data = data;
        left = null;
        right = null;
    }
}

class GFG {

    // simple inorder traversal to store values
    static void inorder(List<int> inord, Node root)
    {
        if (root == null)
            return;

        inorder(inord, root.left);
        inord.Add(root.data); 
        inorder(inord, root.right);
    }

    // function to find minimum absolute difference
    static int absDiff(Node root)
    {
        List<int> inord = new List<int>();

        // inorder of BST gives sorted values
        inorder(inord, root);

        int mini = int.MaxValue;
        int n = inord.Count;

        // since array is sorted, just check adjacent elements
        for (int i = 0; i < n - 1; i++) {
            mini = Math.Min(mini, inord[i + 1] - inord[i]);
        }

        return mini;
    }

    static void Main()
    {
        Node root = new Node(5);
        root.left = new Node(3);
        root.right = new Node(7);
        root.left.left = new Node(2);
        root.left.right = new Node(4);
        root.right.left = new Node(6);
        root.right.right = new Node(8);

        // calling function
        Console.WriteLine(absDiff(root));
    }
}

JavaScript

// class for tree
class Node {
    constructor(data)
    {
        this.data = data;
        this.left = null;
        this.right = null;
    }
}

// simple inorder traversal to store values
function inorder(inord, root)
{
    if (root === null)
        return;

    inorder(inord, root.left);
    inord.push(root.data); 
    inorder(inord, root.right);
}

// function to find minimum absolute difference
function absDiff(root)
{
    let inord = [];

    // inorder of BST gives sorted values
    inorder(inord, root);

    let mini = Number.MAX_SAFE_INTEGER;
    let n = inord.length;

    // since array is sorted, just check adjacent elements
    for (let i = 0; i < n - 1; i++) {
        mini = Math.min(mini, inord[i + 1] - inord[i]);
    }

    return mini;
}

let root = new Node(5);
root.left = new Node(3);
root.right = new Node(7);
root.left.left = new Node(2);
root.left.right = new Node(4);
root.right.left = new Node(6);
root.right.right = new Node(8);

// calling function
console.log(absDiff(root));

Output

Using Inorder Traversal (Without Extra Space) – O(n) Time and O(h) Space

The idea is to use inorder traversal and keep track of the previously visited node during traversal. Since the values are visited in sorted order, the minimum difference will always occur between consecutive nodes.

Perform inorder traversal and maintain a pointer to the previously visited node
At each node, compute the difference with the previous node
Update the minimum difference accordingly
Continue traversal and return the final minimum difference

C++

#include <bits/stdc++.h> 
using namespace std; 

// class for tree node
class Node { 
public:
    int data; 
    Node* left; 
    Node* right; 

    Node(int data) 
    { 
        this->data = data; 
        left = nullptr; 
        right = nullptr; 
    } 
}; 

// inorder traversal while keeping track of previous node
void inorder(Node* curr, Node*& prev, int& ans) 
{ 
    // base case
    if (curr == nullptr) 
        return; 

    // go to left subtree
    inorder(curr->left, prev, ans); 

    // process current node
    if (prev!= nullptr) 
        ans = min(ans, curr->data - prev->data); 

    prev = curr;  // update previous node

    // go to right subtree
    inorder(curr->right, prev, ans); 
} 

// function to find minimum absolute difference in BST
int absDiff(Node* root) 
{ 
    Node* prev = nullptr;  
    int ans = INT_MAX;         

    // inorder traversal (gives sorted order)
    inorder(root, prev, ans); 

    return ans; 
} 

// Driver code 
int main() 
{ 
    Node* root = new Node(5); 
    root->left = new Node(3); 
    root->right = new Node(7); 
    root->left->left = new Node(2); 
    root->left->right = new Node(4); 
    root->right->left = new Node(6); 
    root->right->right = new Node(8); 

    cout << absDiff(root); 

    return 0; 
}

Java

import java.util.*;

// class for tree node
class Node { 
    int data; 
    Node left; 
    Node right; 

    Node(int data) 
    { 
        this.data = data; 
        left = null; 
        right = null; 
    } 
} 

class GFG {

    // inorder traversal while keeping track of previous node
    static void inorder(Node curr, Node[] prev, int[] ans) 
    { 
        // base case
        if (curr == null) 
            return; 

        // go to left subtree
        inorder(curr.left, prev, ans); 

        // process current node
        if (prev[0]!= null) 
            ans[0] = Math.min(ans[0], curr.data - prev[0].data); 
        
        prev[0] = curr;  // update previous node

        // go to right subtree
        inorder(curr.right, prev, ans); 
    } 

    // function to find minimum absolute difference in BST
    static int absDiff(Node root) 
    { 
        Node[] prev = new Node[1];  
        int[] ans = new int[]{Integer.MAX_VALUE};         

        // inorder traversal (gives sorted order)
        inorder(root, prev, ans); 

        return ans[0]; 
    } 

    // Driver code 
    public static void main(String[] args) 
    { 
        Node root = new Node(5); 
        root.left = new Node(3); 
        root.right = new Node(7); 
        root.left.left = new Node(2); 
        root.left.right = new Node(4); 
        root.right.left = new Node(6); 
        root.right.right = new Node(8); 

        System.out.println(absDiff(root)); 
    } 
}

Python

# class for tree node
class Node:
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None

# inorder traversal while keeping track of previous node
def inorder(curr, prev, ans):
    
    # base case
    if curr is None:
        return

    # go to left subtree
    inorder(curr.left, prev, ans)

    # process current node
    if prev[0] is not None:
        ans[0] = min(ans[0], curr.data - prev[0].data)
    
    prev[0] = curr  # update previous node

    # go to right subtree
    inorder(curr.right, prev, ans)

# function to find minimum absolute difference in BST
def absDiff(root):
    prev = [None]
    ans = [float('inf')]

    # inorder traversal (gives sorted order)
    inorder(root, prev, ans)

    return ans[0]


# Driver code
root = Node(5)
root.left = Node(3)
root.right = Node(7)
root.left.left = Node(2)
root.left.right = Node(4)
root.right.left = Node(6)
root.right.right = Node(8)

print(absDiff(root))

C#

using System;

// class for tree node
class Node { 
    public int data; 
    public Node left; 
    public Node right; 

    public Node(int data) 
    { 
        this.data = data; 
        left = null; 
        right = null; 
    } 
} 

class GFG {

    // inorder traversal while keeping track of previous node
    static void inorder(Node curr, ref Node prev, ref int ans) 
    { 
        // base case
        if (curr == null) 
            return; 

        // go to left subtree
        inorder(curr.left, ref prev, ref ans); 

        // process current node
        if (prev!= null) 
            ans = Math.Min(ans, curr.data - prev.data); 
        
        prev = curr;  // update previous node

        // go to right subtree
        inorder(curr.right, ref prev, ref ans); 
    } 

    // function to find minimum absolute difference in BST
    static int absDiff(Node root) 
    { 
        Node prev = null;  
        int ans = int.MaxValue;         

        // inorder traversal (gives sorted order)
        inorder(root, ref prev, ref ans); 

        return ans; 
    } 

    // Driver code 
    static void Main() 
    { 
        Node root = new Node(5); 
        root.left = new Node(3); 
        root.right = new Node(7); 
        root.left.left = new Node(2); 
        root.left.right = new Node(4); 
        root.right.left = new Node(6); 
        root.right.right = new Node(8); 

        Console.WriteLine(absDiff(root)); 
    } 
}

JavaScript

// class for tree Node
class Node { 
    constructor(data) 
    { 
        this.data = data; 
        this.left = null; 
        this.right = null; 
    } 
} 

// inorder traversal while keeping track of previous Node
function inorder(curr, prev, ans) 
{ 
    // base case
    if (curr === null) 
        return; 

    // go to left subtree
    inorder(curr.left, prev, ans); 

    // process current Node
    if (prev.obj!== null) 
        ans.val = Math.min(ans.val, curr.data - prev.obj.data); 

    prev.obj = curr;  // update previous Node

    // go to right subtree
    inorder(curr.right, prev, ans); 
} 

// function to find minimum absolute difference in BST
function absDiff(root) 
{ 
    let prev = { obj: null };  
    let ans = { val: Number.MAX_SAFE_INTEGER };         

    // inorder traversal (gives sorted order)
    inorder(root, prev, ans); 

    return ans.val; 
} 

// Driver code 
let root = new Node(5); 
root.left = new Node(3); 
root.right = new Node(7); 
root.left.left = new Node(2); 
root.left.right = new Node(4); 
root.right.left = new Node(6); 
root.right.right = new Node(8); 

console.log(absDiff(root));

Output

Comment

Article Tags:

Explore