Second largest element in BST

Given a Binary Search Tree(BST), find the second largest element.

Examples:

Input: Root of below BST
    10
   /
  5

Output:  5


Input: Root of below BST
        10
      /   \
    5      20
             \ 
              30 

Output:  20

Source: Microsoft Interview

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

The idea is similar to below post.
K’th Largest Element in BST when modification to BST is not allowed

The second largest element is second last element in inorder traversal and second element in reverse inorder traversal. We traverse given Binary Search Tree in reverse inorder and keep track of counts of nodes visited. Once the count becomes 2, we print the node.

Below is the implementation of above idea.

C++

// C++ program to find 2nd largest element in BST 
#include<bits/stdc++.h> 
using namespace std; 
  
struct Node 
{ 
    int key; 
    Node *left, *right; 
}; 
  
// A utility function to create a new BST node 
Node *newNode(int item) 
{ 
    Node *temp = new Node; 
    temp->key = item; 
    temp->left = temp->right = NULL; 
    return temp; 
} 
  
// A function to find 2nd largest element in a given tree. 
void secondLargestUtil(Node *root, int &c) 
{ 
    // Base cases, the second condition is important to 
    // avoid unnecessary recursive calls 
    if (root == NULL || c >= 2) 
        return; 
  
    // Follow reverse inorder traversal so that the 
    // largest element is visited first 
    secondLargestUtil(root->right, c); 
  
    // Increment count of visited nodes 
    c++; 
  
    // If c becomes k now, then this is the 2nd largest 
    if (c == 2) 
    { 
        cout << "2nd largest element is "
             << root->key << endl; 
        return; 
    } 
  
    // Recur for left subtree 
    secondLargestUtil(root->left, c); 
} 
  
// Function to find 2nd largest element 
void secondLargest(Node *root) 
{ 
    // Initialize count of nodes visited as 0 
    int c = 0; 
  
    // Note that c is passed by reference 
    secondLargestUtil(root, c); 
} 
  
/* A utility function to insert a new node with given key in BST */
Node* insert(Node* node, int key) 
{ 
    /* If the tree is empty, return a new node */
    if (node == NULL) return newNode(key); 
  
    /* Otherwise, recur down the tree */
    if (key < node->key) 
        node->left  = insert(node->left, key); 
    else if (key > node->key) 
        node->right = insert(node->right, key); 
  
    /* return the (unchanged) node pointer */
    return node; 
} 
  
// Driver Program to test above functions 
int main() 
{ 
    /* Let us create following BST 
              50 
           /     \ 
          30      70 
         /  \    /  \ 
       20   40  60   80 */
    Node *root = NULL; 
    root = insert(root, 50); 
    insert(root, 30); 
    insert(root, 20); 
    insert(root, 40); 
    insert(root, 70); 
    insert(root, 60); 
    insert(root, 80); 
  
    secondLargest(root); 
  
    return 0; 
} 

Java

// Java code to find second largest element in BST 
  
// A binary tree node 
class Node { 
  
    int data; 
    Node left, right; 
  
    Node(int d) 
    { 
        data = d; 
        left = right = null; 
    } 
} 
  
class BinarySearchTree { 
  
    // Root of BST 
    Node root; 
  
    // Constructor 
    BinarySearchTree() 
    { 
        root = null; 
    } 
  
    // function to insert new nodes 
    public void insert(int data) 
    { 
        this.root = this.insertRec(this.root, data); 
    } 
      
    /* A utility function to insert a new node with given  
    key in BST */
    Node insertRec(Node node, int data) 
    { 
        /* If the tree is empty, return a new node */
        if (node == null) { 
            this.root = new Node(data); 
            return this.root; 
        } 
  
        /* Otherwise, recur down the tree */
        if (data < node.data) { 
            node.left = this.insertRec(node.left, data); 
        } else { 
            node.right = this.insertRec(node.right, data); 
        } 
        return node; 
    } 
  
    // class that stores the value of count 
    public class count { 
        int c = 0; 
    } 
  
    // Function to find 2nd largest element 
    void secondLargestUtil(Node node, count C) 
    {    
        // Base cases, the second condition is important to 
        // avoid unnecessary recursive calls 
        if (node == null || C.c >= 2) 
            return; 
              
        // Follow reverse inorder traversal so that the 
        // largest element is visited first 
        this.secondLargestUtil(node.right, C);  
          
         // Increment count of visited nodes 
        C.c++; 
          
        // If c becomes k now, then this is the 2nd largest 
        if (C.c == 2) { 
            System.out.print("2nd largest element is "+ 
                                              node.data); 
            return; 
        } 
          
         // Recur for left subtree 
        this.secondLargestUtil(node.left, C);  
    } 
  
    // Function to find 2nd largest element 
    void secondLargest(Node node) 
    {    
        // object of class count 
        count C = new count();  
        this.secondLargestUtil(this.root, C); 
    } 
  
    // Driver function 
    public static void main(String[] args) 
    { 
        BinarySearchTree tree = new BinarySearchTree(); 
          
        /* Let us create following BST 
              50 
           /     \ 
          30      70 
         /  \    /  \ 
       20   40  60   80 */
         
        tree.insert(50); 
        tree.insert(30); 
        tree.insert(20); 
        tree.insert(40); 
        tree.insert(70); 
        tree.insert(60); 
        tree.insert(80); 
  
        tree.secondLargest(tree.root); 
    } 
} 
  
// This code is contributed by Kamal Rawal 

Python3

# Python3 code to find second largest  
# element in BST 
class Node:  
  
    # Constructor to create a new node  
    def __init__(self, data):  
        self.key = data  
        self.left = None
        self.right = None
          
# A function to find 2nd largest  
# element in a given tree.  
def secondLargestUtil(root, c): 
      
    # Base cases, the second condition  
    # is important to avoid unnecessary 
    # recursive calls  
    if root == None or c[0] >= 2:  
        return
  
    # Follow reverse inorder traversal so that  
    # the largest element is visited first  
    secondLargestUtil(root.right, c) 
  
    # Increment count of visited nodes  
    c[0] += 1
  
    # If c becomes k now, then this is 
    # the 2nd largest  
    if c[0] == 2: 
        print("2nd largest element is",  
                              root.key)  
        return
  
    # Recur for left subtree  
    secondLargestUtil(root.left, c) 
  
# Function to find 2nd largest element  
def secondLargest(root): 
      
    # Initialize count of nodes  
    # visited as 0  
    c = [0]  
  
    # Note that c is passed by reference  
    secondLargestUtil(root, c) 
  
# A utility function to insert a new 
# node with given key in BST  
def insert(node, key): 
      
    # If the tree is empty, return a new node  
    if node == None: 
        return Node(key)  
  
    # Otherwise, recur down the tree  
    if key < node.key:  
        node.left = insert(node.left, key)  
    elif key > node.key:  
        node.right = insert(node.right, key)  
  
    # return the (unchanged) node pointer  
    return node 
  
# Driver Code 
if __name__ == '__main__': 
      
    # Let us create following BST  
    #         50  
    #     /     \  
    #     30     70  
    #     / \ / \  
    # 20 40 60 80  
    root = None
    root = insert(root, 50)  
    insert(root, 30) 
    insert(root, 20)  
    insert(root, 40)  
    insert(root, 70)  
    insert(root, 60)  
    insert(root, 80)  
  
    secondLargest(root)  
  
# This code is contributed by PranchalK 

C#

using System; 
  
// C# code to find second largest element in BST  
  
// A binary tree node  
public class Node 
{ 
  
    public int data; 
    public Node left, right; 
  
    public Node(int d) 
    { 
        data = d; 
        left = right = null; 
    } 
} 
  
public class BinarySearchTree 
{ 
  
    // Root of BST  
    public Node root; 
  
    // Constructor  
  public BinarySearchTree() 
    { 
        root = null; 
    } 
  
    // function to insert new nodes  
    public virtual void insert(int data) 
    { 
        this.root = this.insertRec(this.root, data); 
    } 
  
    /* A utility function to insert a new node with given   
    key in BST */
    public virtual Node insertRec(Node node, int data) 
    { 
        /* If the tree is empty, return a new node */
        if (node == null) 
        { 
            this.root = new Node(data); 
            return this.root; 
        } 
  
        /* Otherwise, recur down the tree */
        if (data < node.data) 
        { 
            node.left = this.insertRec(node.left, data); 
        } 
        else
        { 
            node.right = this.insertRec(node.right, data); 
        } 
        return node; 
    } 
  
    // class that stores the value of count  
    public class count 
    { 
        private readonly BinarySearchTree outerInstance; 
  
        public count(BinarySearchTree outerInstance) 
        { 
            this.outerInstance = outerInstance; 
        } 
  
        public int c = 0; 
    } 
  
    // Function to find 2nd largest element  
    public virtual void secondLargestUtil(Node node, count C) 
    { 
        // Base cases, the second condition is important to  
        // avoid unnecessary recursive calls  
        if (node == null || C.c >= 2) 
        { 
            return; 
        } 
  
        // Follow reverse inorder traversal so that the  
        // largest element is visited first  
        this.secondLargestUtil(node.right, C); 
  
         // Increment count of visited nodes  
        C.c++; 
  
        // If c becomes k now, then this is the 2nd largest  
        if (C.c == 2) 
        { 
            Console.Write("2nd largest element is " + node.data); 
            return; 
        } 
  
         // Recur for left subtree  
        this.secondLargestUtil(node.left, C); 
    } 
  
    // Function to find 2nd largest element  
    public virtual void secondLargest(Node node) 
    { 
        // object of class count  
        count C = new count(this); 
        this.secondLargestUtil(this.root, C); 
    } 
  
    // Driver function  
    public static void Main(string[] args) 
    { 
        BinarySearchTree tree = new BinarySearchTree(); 
  
        /* Let us create following BST  
              50  
           /     \  
          30      70  
         /  \    /  \  
       20   40  60   80 */
  
        tree.insert(50); 
        tree.insert(30); 
        tree.insert(20); 
        tree.insert(40); 
        tree.insert(70); 
        tree.insert(60); 
        tree.insert(80); 
  
        tree.secondLargest(tree.root); 
    } 
} 
  
  // This code is contributed by Shrikant13 

Output:

2nd largest element is 70

Time complexity of the above solution is O(h) where h is height of BST.

This article is contributed by Ravi. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

C++

Java

Python3

C#

Recommended Posts: