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++ implementation of the approach
#include
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; } Another Approach with O(1) Space Complexity:

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

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.



Improved By : subhamchakra007