Pair with minimum absolute difference | BST

• Difficulty Level : Medium
• Last Updated : 08 Dec, 2021

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.

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++

 // C++ implementation of the approach#include 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

 // 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#

 // 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



Python3

 # 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))
Output
1

Another Approach with O(N) Space Complexity:

Python3

 # 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))
Output:
1

Time complexity: O(N)
Additional Space: O(N) due to recursion.

My Personal Notes arrow_drop_up