给定大小为N> 1的二叉搜索树，任务是找到任意两个节点之间的最小绝对差。
例子：
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
方法：我们知道二叉搜索树的有序遍历以排序的顺序遍历它。因此，对于每个节点，我们将在树的有序遍历中发现其与前一个节点的不同。如果此差异小于先前的最小差异，我们将更新先前的最小差异。以下是要遵循的步骤：
- 创建一个变量“ prev”以按顺序遍历存储指向上一个节点的指针。
- 创建一个变量“ ans”以存储最小差异。
- 对于有序遍历中的每个节点，将其绝对差与上一个节点进行比较，并更新到目前为止找到的最小绝对差。
下面是上述方法的实现：
C++
// 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;
} Java
// 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 29AjayKumarC#
// 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具有O(1)空间复杂度的另一种方法：
# 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))
输出：
1
时间复杂度： O(N)
额外空间： O(1)
如果您希望与行业专家一起参加现场课程，请参阅《 Geeks现场课程》和《 Geeks现场课程美国》。