Pair with minimum absolute difference | BST

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:



  1. Create a variable ‘prev’ to store the pointer to the previous node in in-order traversal.
  2. Create a variable ‘ans’ to store the minimum difference.
  3. 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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach 
#include <bits/stdc++.h> 
using namespace std; 
    
// Node of the binary tree 
struct node { 
    int data; 
    node* left; 
    node* right; 
    node(int data) 
    
        this->data = data; 
        left = NULL; 
        right = NULL; 
    
}; 
    
// Function for in-order traversal of the tree 
void 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 tree 
int 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 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 << minDiff(root); 
    
    return 0; 
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation of the approach 
import java.util.*;
  
class GFG 
{
      
// Node of the binary tree 
static 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 tree 
static 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 tree 
static 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 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(minDiff(root)); 
}
}
  
// This code is contributed by 29AjayKumar

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation of the approach
using System;
      
class GFG 
{
      
// Node of the binary tree 
public 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 tree 
static 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 tree 
static 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 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); 
      
    Console.WriteLine(minDiff(root)); 
}
}
  
// This code is contributed by PrinciRaj1992

chevron_right


Another Approach with O(1) Space Complexity:

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python 3 implementation of the approach
  
# Node of the binary tree
import math
class Node:  
    
    # Constructor to create a new node  
    def __init__(self, data):  
        self.data = data  
        self.left = None
        self.right = None
#Set the target to infinity
target=math.inf  
#Function to find the minimum absolute difference
def 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 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(absolute_diff(root,target))

chevron_right


Output:

1

Time complexity: O(N)
Additional Space: O(1)



My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.