Pair with minimum absolute difference | BST - GeeksforGeeks

09 May, 2022
Given a binary search tree of size N > 1, the task is to find the minimum absolute difference between any two nodes.
Examples: 
Input: 
          5 
        /   \ 
       3     7 
      / \   / \ 
     2   4 6   8
Output: 1
Difference between all the consecutive nodes if sorted is 1.
Thus, the answer is 1.

Input:
     1
      \
       6
Output: 5
Approach: We know that in-order traversal of a Binary Search Tree traverses it in sorted order. So, for every node, we will find its difference from the previous node in the in-order traversal of the tree. If this difference is smaller than the previous minimum difference, we will update the previous minimum difference. Following are the steps to follow:  
Create a variable ‘prev’ to store the pointer to the previous node in in-order traversal.Create a variable ‘ans’ to store the minimum difference.For every node in the in-order traversal, compare its absolute difference with the previous node and update the minimum absolute difference found so far.
Create a variable ‘prev’ to store the pointer to the previous node in in-order traversal.
Create a variable ‘ans’ to store the minimum difference.
For every node in the in-order traversal, compare its absolute difference with the previous node and update the minimum absolute difference found so far.
Below is the implementation of the above approach:  
C++
Java
C#
Javascript
Python3
// C++ implementation of the approach#include <bits/stdc++.h>using namespace std;   // Node of the binary treestruct node {    int data;    node* left;    node* right;    node(int data)    {        this->data = data;        left = NULL;        right = NULL;    }};   // Function for in-order traversal of the treevoid inorder(node* curr, node*& prev, int& ans){       // Base-case    if (curr == NULL)        return;       // Calling in-order on the left sub-tree    inorder(curr->left, prev, ans);       if (prev != NULL)        ans = min(curr->data - prev->data, ans);    prev = curr;       // Calling in-order on the right sub-tree    inorder(curr->right, prev, ans);}   // Function to return the minimum// difference between any two nodes// of the given binary search treeint minDiff(node* root){       // Pointer to previous node in the    // in-order traversal of the BST    node* prev = NULL;       // To store the final ans    int ans = INT_MAX;       // Call in-order for the BST    inorder(root, prev, ans);       // Returning the final answer    return ans;}   // Driver codeint 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 << minDiff(root);       return 0;}
// Java implementation of the approachimport java.util.*; class GFG{     // Node of the binary treestatic class node{    int data;    node left;    node right;    node(int data)    {        this.data = data;        left = null;        right = null;    }};static node prev;static int ans; // Function for in-order traversal of the treestatic void inorder(node curr){         // Base-case    if (curr == null)        return;         // Calling in-order on the left sub-tree    inorder(curr.left);         if (prev != null)        ans = Math.min(curr.data -                       prev.data, ans);    prev = curr;         // Calling in-order on the right sub-tree    inorder(curr.right);}     // Function to return the minimum// difference between any two nodes// of the given binary search treestatic int minDiff(node root){         // Pointer to previous node in the    // in-order traversal of the BST    prev = null;         // To store the final ans    ans = Integer.MAX_VALUE;         // Call in-order for the BST    inorder(root);         // Returning the final answer    return ans;}     // Driver codepublic 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(minDiff(root));}} // This code is contributed by 29AjayKumar
// C# implementation of the approachusing System;     class GFG{     // Node of the binary treepublic class node{    public int data;    public node left;    public node right;    public node(int data)    {        this.data = data;        left = null;        right = null;    }};static node prev;static int ans; // Function for in-order traversal of the treestatic void inorder(node curr){         // Base-case    if (curr == null)        return;         // Calling in-order on the left sub-tree    inorder(curr.left);         if (prev != null)        ans = Math.Min(curr.data -                       prev.data, ans);    prev = curr;         // Calling in-order on the right sub-tree    inorder(curr.right);}     // Function to return the minimum// difference between any two nodes// of the given binary search treestatic int minDiff(node root){         // Pointer to previous node in the    // in-order traversal of the BST    prev = null;         // To store the final ans    ans = int.MaxValue;         // Call in-order for the BST    inorder(root);         // Returning the final answer    return ans;}     // Driver codepublic 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);         Console.WriteLine(minDiff(root));}} // This code is contributed by PrinciRaj1992
<script> // Javascript implementation of the approach         // Node of the binary treeclass node{    constructor(data)    {        this.data = data;        this.left = null;        this.right = null;    }}; var prev = null;var ans =0; // Function for in-order traversal of the treefunction inorder(curr){         // Base-case    if (curr == null)        return;         // Calling in-order on the left sub-tree    inorder(curr.left);         if (prev != null)        ans = Math.min(curr.data -                       prev.data, ans);    prev = curr;         // Calling in-order on the right sub-tree    inorder(curr.right);}     // Function to return the minimum// difference between any two nodes// of the given binary search treefunction minDiff(root){         // Pointer to previous node in the    // in-order traversal of the BST    prev = null;         // To store the final ans    ans = 10000000000;         // Call in-order for the BST    inorder(root);         // Returning the final answer    return ans;}     // Driver codevar 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); document.write(minDiff(root)); // This code is contributed by noob2000 </script>
# Python 3 implementation of the approachimport math# Node of the binary tree  class node:    def __init__(self, data):        self.data = data        self.left = None        self.right = None # Function for in-order traversal of the tree  def inorder(curr, prev):    global ans     # Base-case    if (curr == None):        return     # Calling in-order on the left sub-tree    inorder(curr.left, prev)     if (prev != None):        ans = min(curr.data - prev.data, ans)    prev = curr     # Calling in-order on the right sub-tree    inorder(curr.right, prev) # Function to return the minimum# difference between any two nodes# of the given binary search tree  def minDiff(root):     # Pointer to previous node in the    # in-order traversal of the BST    prev = None     # To store the final ans    global ans    ans = math.inf     # Call in-order for the BST    inorder(root, prev)     # Returning the final answer    return ans  # Driver codeif __name__ == '__main__':     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(minDiff(root))
1
Another Approach with O(N) Space Complexity:
Python3
Javascript
# Python 3 implementation of the approach # Node of the binary treeimport mathclass Node:        # Constructor to create a new node     def __init__(self, data):         self.data = data         self.left = None        self.right = None#Set the target to infinitytarget=math.inf #Function to find the minimum absolute differencedef absolute_diff(root,target):    if root is None:        return target        if root.left is not None:        left=root.data-root.left.data        target=min(target,left)    if root.right is not None:        right=root.right.data-root.data        target=min(target,right)    #Find the minimum in the left subtree    p=absolute_diff(root.left,target)    #Find the minimum in the right subtree    q=absolute_diff(root.right,target)    return min(p,q) // Driver coderoot=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(absolute_diff(root,target))
<script> //  JavaScript implementation of the approach //  Node of the binary treeclass Node{     //  Constructor to create a new node    constructor(data){        this.data = data        this.left = null        this.right = null    }} // Set the target to infinitylet target = Number.MAX_VALUE // Function to find the minimum absolute differencefunction absolute_diff(root, target){    if(root == null)        return target         if(root.left !== null){        let left = root.data - root.left.data        target = Math.min(target, left)    }    if(root.right !== null){        let right = root.right.data - root.data        target = Math.min(target, right)    }    // Find the minimum in the left subtree    let p = absolute_diff(root.left, target)         // Find the minimum in the right subtree    let q = absolute_diff(root.right, target)    return Math.min(p, q)} // Driver codelet 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)document.write(absolute_diff(root,target),"</br>") // This code is contributed by shinjanpatra </script>
1
 
Time complexity: O(N) Additional Space: O(N) due to recursion. 
subhamchakra007
29AjayKumar
princiraj1992
noob2000
ashutoshsinghgeeksforgeeks
amartyaghoshgfg
shinjanpatra
Binary Search Tree
Data Structures
Tree
Data Structures
Binary Search Tree
Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Sorted Array to Balanced BST
Red-Black Tree | Set 2 (Insert)
Optimal Binary Search Tree | DP-24
Inorder Successor in Binary Search Tree
Find the node with minimum value in a Binary Search Tree
SDE SHEET - A Complete Guide for SDE Preparation
Top 50 Array Coding Problems for Interviews
DSA Sheet by Love Babbar
Doubly Linked List | Set 1 (Introduction and Insertion)
Introduction to Algorithms