Pair with minimum absolute difference in BST

// C# program for the above approach
using System;
using System.Collections.Generic;

// class for tree.
public class TreeNode {
    public int val;
    public TreeNode left;
    public TreeNode right;
    public TreeNode(int val) {
        this.val = val;
        left = null;
        right = null;
    }
}

public class GFG
{
  
    // preorder finder function.
    public static void preorder(TreeNode root, List<int> v) {
        if (root == null)
            return;
        v.Add(root.val);
        preorder(root.left, v);
        preorder(root.right, v);
    }

    public static void Main(string[] args) {
        // BSTree
        TreeNode root = new TreeNode(5);
        root.left = new TreeNode(3);
        root.right = new TreeNode(7);
        root.left.left = new TreeNode(2);
        root.left.right = new TreeNode(4);
        root.right.left = new TreeNode(6);
        root.right.right = new TreeNode(8);

        List<int> v = new List<int>();
      
        // call for preorder.
        preorder(root, v);
        int min_diff = int.MaxValue;
        int n = v.Count;
      
        // traversing and checking.
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                int x = Math.Abs(v[i] - v[j]);
                if (min_diff > x) {
                    min_diff = x;
                }
            }
        }
        // printing the output.
        Console.WriteLine("the minimum difference is : " + min_diff);
    }
}

// This code is contributed by rishabmalhdijo

//C# code for the above approach
using System;
using System.Collections.Generic;

class GFG
{
  // Node of the binary tree
  public class TreeNode
  {
    public int data;
    public TreeNode left;
    public TreeNode right;
    public TreeNode(int data)
    {
      this.data = data;
      left = null;
      right = null;
    }
  }

  // Function to perform inorder traversal of the tree
  public static void inorder(List<int> inord, TreeNode root)
  {
    if (root == null)
      return;
    inorder(inord, root.left);
    inord.Add(root.data);
    inorder(inord, root.right);
  }

  public static int getMinimumDifference(TreeNode root)
  {
    List<int> inord = new List<int>();
    inorder(inord, root);
    int mini = int.MaxValue;
    int N = inord.Count;

    for (int i = 0; i < N - 1; i++)
    {
      mini = Math.Min(mini, inord[i + 1] - inord[i]);
    }

    return mini;
  }

  public static void Main(string[] args)
  {
    TreeNode root = new TreeNode(5);
    root.left = new TreeNode(3);
    root.right = new TreeNode(7);
    root.left.left = new TreeNode(2);
    root.left.right = new TreeNode(4);
    root.right.left = new TreeNode(6);
    root.right.right = new TreeNode(8);
    Console.WriteLine(getMinimumDifference(root));
  }
}
//This code is contributed by Potta Lokesh

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