Maximum element between two nodes of BST - GeeksforGeeks

19 Apr, 2022
Given an array of N elements and two integers A, B which belong to the given array. Create a Binary Search Tree by inserting elements from arr[0] to arr[n-1]. The task is to find the maximum element in the path from A to B.Examples :  
Input : arr[] = { 18, 36, 9, 6, 12, 10, 1, 8 }, 
        a = 1, 
        b = 10.
Output : 12
 
Path from 1 to 10 contains { 1, 6, 9, 12, 10 }. Maximum element is 12. 
The idea is to find Lowest Common Ancestor of node ‘a’ and node ‘b’. Then search maximum node between LCA and ‘a’, also find maximum node between LCA and ‘b’. Answer will be maximum node of two. 
C++
Java
Python3
C#
Javascript
// C++ program to find maximum element in the path// between two Nodes of Binary Search Tree.#include <bits/stdc++.h>using namespace std; struct Node{    struct Node *left, *right;    int data;}; // Create and return a pointer of new Node.Node *createNode(int x){    Node *p = new Node;    p -> data = x;    p -> left = p -> right = NULL;    return p;} // Insert a new Node in Binary Search Tree.void insertNode(struct Node *root, int x){    Node *p = root, *q = NULL;     while (p != NULL)    {        q = p;        if (p -> data < x)            p = p -> right;        else            p = p -> left;    }     if (q == NULL)        p = createNode(x);    else    {        if (q -> data < x)            q -> right = createNode(x);        else            q -> left = createNode(x);    }} // Return the maximum element between a Node// and its given ancestor.int maxelpath(Node *q, int x){    Node *p = q;     int mx = INT_MIN;     // Traversing the path between ancestor and    // Node and finding maximum element.    while (p -> data != x)    {        if (p -> data > x)        {            mx = max(mx, p -> data);            p = p -> left;        }        else        {            mx = max(mx, p -> data);            p = p -> right;        }    }     return max(mx, x);} // Return maximum element in the path between// two given Node of BST.int maximumElement(struct Node *root, int x, int y){    Node *p = root;     // Finding the LCA of Node x and Node y    while ((x < p -> data && y < p -> data) ||        (x > p -> data && y > p -> data))    {        // Checking if both the Node lie on the        // left side of the parent p.        if (x < p -> data && y < p -> data)            p = p -> left;         // Checking if both the Node lie on the        // right side of the parent p.        else if (x > p -> data && y > p -> data)            p = p -> right;    }     // Return the maximum of maximum elements occur    // in path from ancestor to both Node.    return max(maxelpath(p, x), maxelpath(p, y));}  // Driver Codeint main(){    int arr[] = { 18, 36, 9, 6, 12, 10, 1, 8 };    int a = 1, b = 10;    int n = sizeof(arr) / sizeof(arr[0]);     // Creating the root of Binary Search Tree    struct Node *root = createNode(arr[0]);     // Inserting Nodes in Binary Search Tree    for (int i = 1; i < n; i++)        insertNode(root, arr[i]);     cout << maximumElement(root, a, b) << endl;     return 0;}
// Java program to find maximum element in the path// between two Nodes of Binary Search Tree.class Solution{     static class Node{     Node left, right;    int data;}  // Create and return a pointer of new Node.static Node createNode(int x){    Node p = new Node();    p . data = x;    p . left = p . right = null;    return p;}  // Insert a new Node in Binary Search Tree.static void insertNode( Node root, int x){    Node p = root, q = null;      while (p != null)    {        q = p;        if (p . data < x)            p = p . right;        else            p = p . left;    }      if (q == null)        p = createNode(x);    else    {        if (q . data < x)            q . right = createNode(x);        else            q . left = createNode(x);    }}  // Return the maximum element between a Node// and its given ancestor.static int maxelpath(Node q, int x){    Node p = q;      int mx = -1;      // Traversing the path between ancestor and    // Node and finding maximum element.    while (p . data != x)    {        if (p . data > x)        {            mx = Math.max(mx, p . data);            p = p . left;        }        else        {            mx = Math.max(mx, p . data);            p = p . right;        }    }      return Math.max(mx, x);}  // Return maximum element in the path between// two given Node of BST.static int maximumElement( Node root, int x, int y){    Node p = root;      // Finding the LCA of Node x and Node y    while ((x < p . data && y < p . data) ||        (x > p . data && y > p . data))    {        // Checking if both the Node lie on the        // left side of the parent p.        if (x < p . data && y < p . data)            p = p . left;          // Checking if both the Node lie on the        // right side of the parent p.        else if (x > p . data && y > p . data)            p = p . right;    }      // Return the maximum of maximum elements occur    // in path from ancestor to both Node.    return Math.max(maxelpath(p, x), maxelpath(p, y));}    // Driver Codepublic static void main(String args[]){    int arr[] = { 18, 36, 9, 6, 12, 10, 1, 8 };    int a = 1, b = 10;    int n =arr.length;      // Creating the root of Binary Search Tree     Node root = createNode(arr[0]);      // Inserting Nodes in Binary Search Tree    for (int i = 1; i < n; i++)        insertNode(root, arr[i]);      System.out.println( maximumElement(root, a, b) );  }}//contributed by Arnab Kundu
# Python 3 program to find maximum element# in the path between two Nodes of Binary# Search Tree. # Create and return a pointer of new Node.class createNode:     # Constructor to create a new node    def __init__(self, data):        self.data = data        self.left = None        self.right = None # Insert a new Node in Binary Search Tree.def insertNode(root, x):    p, q = root, None     while p != None:        q = p        if p.data < x:            p = p.right        else:            p = p.left     if q == None:        p = createNode(x)    else:        if q.data < x:            q.right = createNode(x)        else:            q.left = createNode(x) # Return the maximum element between a# Node and its given ancestor.def maxelpath(q, x):    p = q     mx = -999999999999     # Traversing the path between ancestor    # and Node and finding maximum element.    while p.data != x:        if p.data > x:            mx = max(mx, p.data)            p = p.left        else:            mx = max(mx, p.data)            p = p.right     return max(mx, x) # Return maximum element in the path# between two given Node of BST.def maximumElement(root, x, y):    p = root     # Finding the LCA of Node x and Node y    while ((x < p.data and y < p.data) or           (x > p.data and y > p.data)):                        # Checking if both the Node lie on        # the left side of the parent p.        if x < p.data and y < p.data:            p = p.left         # Checking if both the Node lie on        # the right side of the parent p.        elif x > p.data and y > p.data:            p = p.right     # Return the maximum of maximum elements    # occur in path from ancestor to both Node.    return max(maxelpath(p, x), maxelpath(p, y)) # Driver Codeif __name__ == '__main__':    arr = [ 18, 36, 9, 6, 12, 10, 1, 8]    a, b = 1, 10    n = len(arr)     # Creating the root of Binary Search Tree    root = createNode(arr[0])     # Inserting Nodes in Binary Search Tree    for i in range(1,n):        insertNode(root, arr[i])     print(maximumElement(root, a, b)) # This code is contributed by PranchalK
using System; // C# program to find maximum element in the path// between two Nodes of Binary Search Tree.public class Solution{ public class Node{     public Node left, right;    public int data;} // Create and return a pointer of new Node.public static Node createNode(int x){    Node p = new Node();    p.data = x;    p.left = p.right = null;    return p;} // Insert a new Node in Binary Search Tree.public static void insertNode(Node root, int x){    Node p = root, q = null;     while (p != null)    {        q = p;        if (p.data < x)        {            p = p.right;        }        else        {            p = p.left;        }    }     if (q == null)    {        p = createNode(x);    }    else    {        if (q.data < x)        {            q.right = createNode(x);        }        else        {            q.left = createNode(x);        }    }} // Return the maximum element between a Node// and its given ancestor.public static int maxelpath(Node q, int x){    Node p = q;     int mx = -1;     // Traversing the path between ancestor and    // Node and finding maximum element.    while (p.data != x)    {        if (p.data > x)        {            mx = Math.Max(mx, p.data);            p = p.left;        }        else        {            mx = Math.Max(mx, p.data);            p = p.right;        }    }     return Math.Max(mx, x);} // Return maximum element in the path between// two given Node of BST.public static int maximumElement(Node root, int x, int y){    Node p = root;     // Finding the LCA of Node x and Node y    while ((x < p.data && y < p.data) || (x > p.data && y > p.data))    {        // Checking if both the Node lie on the        // left side of the parent p.        if (x < p.data && y < p.data)        {            p = p.left;        }         // Checking if both the Node lie on the        // right side of the parent p.        else if (x > p.data && y > p.data)        {            p = p.right;        }    }     // Return the maximum of maximum elements occur    // in path from ancestor to both Node.    return Math.Max(maxelpath(p, x), maxelpath(p, y));}  // Driver Codepublic static void Main(string[] args){    int[] arr = new int[] {18, 36, 9, 6, 12, 10, 1, 8};    int a = 1, b = 10;    int n = arr.Length;     // Creating the root of Binary Search Tree     Node root = createNode(arr[0]);     // Inserting Nodes in Binary Search Tree    for (int i = 1; i < n; i++)    {        insertNode(root, arr[i]);    }     Console.WriteLine(maximumElement(root, a, b)); }}   //  This code is contributed by Shrikant13
<script> // JavaScript program to find// maximum element in the path// between two Nodes of Binary// Search Tree.       class Node {            constructor(val) {                this.data = val;                this.left = null;                this.right = null;            }        }           // Create and return a pointer of new Node.    function createNode(x) {var p = new Node();        p.data = x;        p.left = p.right = null;        return p;    }     // Insert a new Node in Binary Search Tree.    function insertNode(root , x) {       var p = root, q = null;         while (p != null) {            q = p;            if (p.data < x)                p = p.right;            else                p = p.left;        }         if (q == null)            p = createNode(x);        else {            if (q.data < x)                q.right = createNode(x);            else                q.left = createNode(x);        }    }     // Return the maximum element between a Node    // and its given ancestor.    function maxelpath(q , x) {        var p = q;         var mx = -1;         // Traversing the path between ancestor and        // Node and finding maximum element.        while (p.data != x) {            if (p.data > x) {                mx = Math.max(mx, p.data);                p = p.left;            } else {                mx = Math.max(mx, p.data);                p = p.right;            }        }         return Math.max(mx, x);    }     // Return maximum element in the path between    // two given Node of BST.    function maximumElement(root , x , y) {     var p = root;         // Finding the LCA of Node x and Node y        while ((x < p.data && y < p.data) ||        (x > p.data && y > p.data)) {            // Checking if both the Node lie on the            // left side of the parent p.            if (x < p.data && y < p.data)                p = p.left;             // Checking if both the Node lie on the            // right side of the parent p.            else if (x > p.data && y > p.data)                p = p.right;        }         // Return the maximum of maximum elements occur        // in path from ancestor to both Node.        return Math.max(maxelpath(p, x), maxelpath(p, y));    }     // Driver Code             var arr = [ 18, 36, 9, 6, 12, 10, 1, 8 ];        var a = 1, b = 10;        var n = arr.length;         // Creating the root of Binary Search Tree        var root = createNode(arr[0]);         // Inserting Nodes in Binary Search Tree        for (i = 1; i < n; i++)            insertNode(root, arr[i]);         document.write(maximumElement(root, a, b));  // This code contributed by gauravrajput1 </script>
Output:  
12
Time complexity: O(h) where h is height of BSTThis article is contributed by Anuj Chauhan. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
sanjeetkumarSingh
andrew1234
shrikanth13
PranchalKatiyar
GauravRajput1
simmytarika5
LCA
Binary Search Tree
Binary Search Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Sorted Array to Balanced BST
Inorder Successor in Binary Search Tree
Optimal Binary Search Tree | DP-24
Find the node with minimum value in a Binary Search Tree
Overview of Data Structures | Set 2 (Binary Tree, BST, Heap and Hash)
Difference between Binary Tree and Binary Search Tree
Lowest Common Ancestor in a Binary Search Tree.
Binary Tree to Binary Search Tree Conversion
Find k-th smallest element in BST (Order Statistics in BST)
Convert a normal BST to Balanced BST