# 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 8Output:1 Difference between all the consecutive nodes if sorted is 1. Thus, the answer is 1.Input:1 \ 6Output: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.

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)

## Recommended Posts:

- Pair with minimum absolute difference after solving each query
- Find the minimum absolute difference in two different BST's
- Find the node whose absolute difference with X gives minimum value
- Find the node whose absolute difference with X gives maximum value
- Sort an array according to absolute difference with given value using Functors
- Queries to add, remove and return the difference of maximum and minimum.
- Sub-tree with minimum color difference in a 2-coloured tree
- Pair with a given sum in BST | Set 2
- Find a pair with given sum in BST
- Find a pair with given sum in a Balanced BST
- Find pairs with given sum such that pair elements lie in different BSTs
- Find the number of pair of Ideal nodes in a given tree
- Number of distinct pair of edges such that it partitions both trees into same subsets of nodes
- Find if there is a pair in root to a leaf path with sum equals to root's data
- Difference between graph and tree

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.