Maximum element between two nodes of BST

// C# program to find the maximum element in the path
// between two Nodes of Binary Search Tree.

using System;
using System.Collections.Generic;

class Node {
    public int data;
    public Node left, right;
    public Node(int x) {
        data = x;
        left = right = null;
    }
}

class GfG {
  
    // Insert a new Node in Binary Search Tree
    static public void insertNode(Node root, int x) {
        Node current = root, parent = null;

        // Traverse to the correct position
      	// for insertion
        while (current != null) {
            parent = current;
            if (x < current.data)
                current = current.left;
            else
                current = current.right;
        }

        // Insert new Node at the correct
      	// position
        if (parent == null)
            root = new Node(x);
        else if (x < parent.data)
            parent.left = new Node(x);
        else
            parent.right = new Node(x);
    }

    // DFS to populate parent map for each node
    static public void dfs(Node root, 
	Dictionary<Node, Node> parentMap, Node parent) {
        if (root == null)
            return;

        // Store the parent of the current node
        if (parent != null) {
            parentMap[root] = parent;
        }

        // Recur for left and right children
        dfs(root.left, parentMap, root);
        dfs(root.right, parentMap, root);
    }

    // Function to find the node with the given
  	// value in the BST
    static public Node findNode(Node root, int val) {
        if (root == null)
            return null;

        if (root.data == val)
            return root;

        Node leftResult = findNode(root.left, val);
        if (leftResult != null)
            return leftResult;

        return findNode(root.right, val);
    }

    // Find maximum element in the path between 
  	// two nodes in BST
    static public int findMaxElement(Node root, int x, int y) {
        Dictionary<Node, Node> parentMap = new Dictionary<Node, Node>();

        // Populate parent map with DFS
        dfs(root, parentMap, null);

        // Find the nodes corresponding to 
      	// the values x and y
        Node p1 = findNode(root, x);
        Node p2 = findNode(root, y);

        // If nodes not found
        if (p1 == null || p2 == null)
            return -1;

        // Sets to store nodes encountered 
        // while traversing up the tree
        HashSet<Node> s1 = new HashSet<Node>();
        HashSet<Node> s2 = new HashSet<Node>();

        // Variable to store the maximum element 
      	// in the path
        int maxElement = int.MinValue;

        // Traverse up the tree from p1 and p2 
        // and add nodes to sets s1 and s2
        while (p1 != p2) {
            if (p1 != null) {
                s1.Add(p1);
                maxElement = Math.Max(maxElement, p1.data);

                // Move to parent node
                p1 = parentMap[p1];
            }

            if (p2 != null) {
                s2.Add(p2);
                maxElement = Math.Max(maxElement, p2.data);
                p2 = parentMap[p2];
            }

            // Check if there's a common node in both sets
            if (s1.Contains(p2))
                break;
            if (s2.Contains(p1))
                break;
        }

        // Now both p1 and p2 point to their Lowest 
      	// Common Ancestor (LCA)
        maxElement = Math.Max(maxElement, p1.data);

        return maxElement;
    }

    static void Main() {
        int[] arr = {18, 36, 9, 6, 12, 10, 1, 8};
        int a = 1, b = 10;
        int n = arr.Length;
        Node root = new Node(arr[0]);
        for (int i = 1; i < n; i++)
            insertNode(root, arr[i]);
        Console.WriteLine(findMaxElement(root, a, b));
    }
}

// C# program to find maximum element in the path
// between two Nodes of Binary Search Tree.

using System;

class Node {
    public int data;
    public Node left, right;
    public Node(int x) {
        data = x;
        left = right = null;
    }
}

class GfG {
  
    // Insert a new Node in Binary Search Tree
    static void insertNode(Node root, int x) {
        Node current = root, parent = null;

        // Traverse to the correct position
      	// for insertion
        while (current != null) {
            parent = current;
            if (x < current.data)
                current = current.left;
            else
                current = current.right;
        }

        // Insert new Node at the correct position
        if (parent == null)
            root = new Node(x);
        else if (x < parent.data)
            parent.left = new Node(x);
        else
            parent.right = new Node(x);
    }

    // Find maximum element in the path from an 
  	// ancestor to a node
    static int maxInPath(Node root, int x) {
        int maxElement = int.MinValue;
        Node current = root;

        // Traverse the path from root to the target node 'x'
        while (current != null && current.data != x) {
            maxElement = Math.Max(maxElement, current.data);
            if (x < current.data)
                current = current.left;
            else
                current = current.right;
        }

        return Math.Max(maxElement, x);
    }

    // Find maximum element in the path between two nodes in BST
    static int findMaxElement(Node root, int x, int y) {
        Node current = root;

        // Find Lowest Common Ancestor (LCA) of x and y
        while ((x < current.data && y < current.data) 
               || (x > current.data && y > current.data)) {
            if (x < current.data && y < current.data)
                current = current.left;
            else if (x > current.data && y > current.data)
                current = current.right;
        }

        // Find maximum elements in paths from
      	// LCA to x and LCA to y
        return Math.Max(maxInPath(current, x), maxInPath(current, y));
    }

     static void Main() {
        int[] arr = {18, 36, 9, 6, 12, 10, 1, 8};
        int a = 1, b = 10;
        Node root = new Node(arr[0]);
       
        for (int i = 1; i < arr.Length; i++)
            insertNode(root, arr[i]);
        Console.WriteLine(findMaxElement(root, a, b));
    }
}