Open In App
Related Articles

Maximum element between two nodes of BST

Improve Article
Improve
Save Article
Save
Like Article
Like

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 }. The 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’, and also find the maximum node between LCA and ‘b’. The answer will be maximum node of two.

Implementation:

C++




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



// 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 Code
public 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
Python3



# 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 Code
if __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
C#



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 Code
public 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
Javascript



<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 the height of BST
Auxiliary Space: O(1)
Approach: Use a hash table to store the parent node of each node in the binary search tree. We can start from both the given nodes and traverse up the tree, storing the nodes encountered in a set. Once we reach the root or a common ancestor of the two nodes, we can traverse down the tree from each node and find the maximum element encountered in the set of nodes.
Algorithm steps for the above approach:
  • Create an empty hash table to store the parent node of each node in the binary search tree.
  • Perform a depth-first search (DFS) traversal of the binary search tree and populate the hash table with the parent node of each node.
  • Initialize two pointers, say p1 and p2, to the given nodes.
  • Initialize two empty sets, say s1 and s2, to store the nodes encountered while traversing up the tree from p1 and p2, respectively.
  • While p1 and p2 are not equal, do the following:
    a. If p1 is not null, add it to set s1 and update p1 to its parent node using the hash table.
    b. If p2 is not null, add it to set s2 and update p2 to its parent node using the hash table.
  • Find the intersection set of s1 and s2, i.e., the set of nodes that are common to both s1 and s2.
  • Initialize a variable, say max_element, to the minimum integer value.
  • For each node in the intersection set, traverse down the tree from the node to the given nodes and find the maximum element encountered. Update max_element if a greater element is encountered.
  • Return max_element.
Below is the implementation of the above approach:
C++



// 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 Code
int 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;
}
Python3



# Python program for the above approach
class 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):
    if root is None:
        return Node(x)
 
    if x < root.data:
        root.left = insertNode(root.left, x)
    elif x > root.data:
        root.right = insertNode(root.right, x)
 
    return root
 
# Return the maximum element between a Node and its given ancestor.
def maxelpath(q, x):
    p = q
    mx = float('-inf')
 
    # Traversing the path between ancestor and Node and finding the 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 Code
arr = [18, 36, 9, 6, 12, 10, 1, 8]
a, b = 1, 10
n = len(arr)
 
# Creating the root of Binary Search Tree
root = None
for i in range(n):
    root = insertNode(root, arr[i])
 
print(maximumElement(root, a, b))
Javascript



// JavaScript Program for the above approach
class Node {
    constructor(data) {
        this.data = data;
        this.left = null;
        this.right = null;
    }
}
 
// Insert a new Node in Binary Search Tree.
function insertNode(root, x) {
    if (root === null) {
        return new Node(x);
    }
 
    if (x < root.data) {
        root.left = insertNode(root.left, x);
    } else if (x > root.data) {
        root.right = insertNode(root.right, x);
    }
 
    return root;
}
 
// Return the maximum element between a Node and its given ancestor.
function maxelpath(q, x) {
    let p = q;
    let mx = Number.MIN_SAFE_INTEGER;
 
    // Traversing the path between ancestor and Node and finding the 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) {
    let 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
const arr = [18, 36, 9, 6, 12, 10, 1, 8];
const a = 1, b = 10;
const n = arr.length;
 
// Creating the root of Binary Search Tree
let root = null;
for (let i = 0; i < n; i++) {
    root = insertNode(root, arr[i]);
}
 
console.log(maximumElement(root, a, b));
// THIS CODE IS CONTRIBUTED BY PIYUSH AGARWAL
Output:
12

Time complexity: O(n), where n is the number of nodes in the binary search tree.
Auxiliary Space: O(n)
This 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. 

Last Updated :
13 Sep, 2023
Like Article

Save Article

Similar Reads
Similar read thumbnail
Two nodes of a BST are swapped, correct the BST
Similar read thumbnail
K'th Largest Element in BST when modification to BST is not allowed
Similar read thumbnail
Find k-th smallest element in BST (Order Statistics in BST)
Similar read thumbnail
Maximum absolute difference between the sibling nodes of given BST
Similar read thumbnail
Shortest distance between two nodes in BST
Similar read thumbnail
Implementing a BST where every node stores the maximum number of nodes in the path till any leaf
Similar read thumbnail
Correct BST whose two nodes are swapped (using Morris Traversal)
Similar read thumbnail
Find two nodes in the BST whose product equals to the target value
Similar read thumbnail
Find a set of at most N/2 nodes from a Graph such that all remaining nodes are directly connected to one of the chosen nodes
Similar read thumbnail
Common nodes in the inorder sequence of a tree between given two nodes in O(1) space
Related Tutorials
Similar read thumbnail
Mathematical and Geometric Algorithms - Data Structure and Algorithm Tutorials
Similar read thumbnail
Learn Data Structures with Javascript | DSA Tutorial
Similar read thumbnail
Introduction to Max-Heap – Data Structure and Algorithm Tutorials
Similar read thumbnail
Introduction to Set – Data Structure and Algorithm Tutorials
Similar read thumbnail
Introduction to Map – Data Structure and Algorithm Tutorials
Previous
Find a pair with given sum in BST
Next

Find the largest BST subtree in a given Binary Tree | Set 3
Article Contributed By :
author
anuj0503
anuj0503
Vote for difficulty
Current difficulty :
Medium





Improved By :
Article Tags :
Practice Tags :
Report Issue 
We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox