# 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<iostream>
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
```

Output:
`2nd largest element is 70`

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

# GATE CS Corner    Company Wise Coding Practice

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.
2.2 Average Difficulty : 2.2/5.0
Based on 27 vote(s)