Given a Binary Search Tree (BST) and a positive integer k, find the k’th largest element in the Binary Search Tree.
For example, in the following BST, if k = 3, then output should be 14, and if k = 5, then output should be 10.
We have discussed two methods in this post. The method 1 requires O(n) time. The method 2 takes O(h) time where h is height of BST, but requires augmenting the BST (storing count of nodes in left subtree with every node).
Can we find k’th largest element in better than O(n) time and no augmentation?
Approach:
- The idea is to do reverse inorder traversal of BST. Keep a count of nodes visited.
- The reverse inorder traversal traverses all nodes in decreasing order, i.e, visit the right node then centre then left and continue traversing the nodes recursively.
- While doing the traversal, keep track of the count of nodes visited so far.
- When the count becomes equal to k, stop the traversal and print the key.
Implementation:
// C++ program to find k'th 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 k'th largest element in a given tree. void kthLargestUtil(Node *root, int k, int &c)
{ // Base cases, the second condition is important to
// avoid unnecessary recursive calls
if (root == NULL || c >= k)
return ;
// Follow reverse inorder traversal so that the
// largest element is visited first
kthLargestUtil(root->right, k, c);
// Increment count of visited nodes
c++;
// If c becomes k now, then this is the k'th largest
if (c == k)
{
cout << "K'th largest element is "
<< root->key << endl;
return ;
}
// Recur for left subtree
kthLargestUtil(root->left, k, c);
} // Function to find k'th largest element void kthLargest(Node *root, int k)
{ // Initialize count of nodes visited as 0
int c = 0;
// Note that c is passed by reference
kthLargestUtil(root, k, 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);
int c = 0;
for ( int k=1; k<=7; k++)
kthLargest(root, k);
return 0;
} |
// Java code to find k'th 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 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;
}
if (data == node.data) {
return node;
}
/* 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 ;
}
// utility function to find kth largest no in
// a given tree
void kthLargestUtil(Node node, int k, count C)
{
// Base cases, the second condition is important to
// avoid unnecessary recursive calls
if (node == null || C.c >= k)
return ;
// Follow reverse inorder traversal so that the
// largest element is visited first
this .kthLargestUtil(node.right, k, C);
// Increment count of visited nodes
C.c++;
// If c becomes k now, then this is the k'th largest
if (C.c == k) {
System.out.println(k + "th largest element is " +
node.data);
return ;
}
// Recur for left subtree
this .kthLargestUtil(node.left, k, C);
}
// Method to find the kth largest no in given BST
void kthLargest( int k)
{
count c = new count(); // object of class count
this .kthLargestUtil( this .root, k, 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 );
for ( int i = 1 ; i <= 7 ; i++) {
tree.kthLargest(i);
}
}
} // This code is contributed by Kamal Rawal |
# Python3 program to find k'th 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 k'th largest # element in a given tree. def kthLargestUtil(root, k, c):
# Base cases, the second condition
# is important to avoid unnecessary
# recursive calls
if root = = None or c[ 0 ] > = k:
return
# Follow reverse inorder traversal
# so that the largest element is
# visited first
kthLargestUtil(root.right, k, c)
# Increment count of visited nodes
c[ 0 ] + = 1
# If c becomes k now, then this is
# the k'th largest
if c[ 0 ] = = k:
print ( "K'th largest element is" ,
root.key)
return
# Recur for left subtree
kthLargestUtil(root.left, k, c)
# Function to find k'th largest element def kthLargest(root, k):
# Initialize count of nodes
# visited as 0
c = [ 0 ]
# Note that c is passed by reference
kthLargestUtil(root, k, 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 )
for k in range ( 1 , 8 ):
kthLargest(root, k)
# This code is contributed by PranchalK |
using System;
// C# code to find k'th 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 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;
}
if (data == node.data)
{
return node;
}
/* 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;
}
internal int c = 0;
}
// utility function to find kth largest no in
// a given tree
public virtual void kthLargestUtil(Node node, int k, count C)
{
// Base cases, the second condition is important to
// avoid unnecessary recursive calls
if (node == null || C.c >= k)
{
return ;
}
// Follow reverse inorder traversal so that the
// largest element is visited first
this .kthLargestUtil(node.right, k, C);
// Increment count of visited nodes
C.c++;
// If c becomes k now, then this is the k'th largest
if (C.c == k)
{
Console.WriteLine(k + "th largest element is " + node.data);
return ;
}
// Recur for left subtree
this .kthLargestUtil(node.left, k, C);
}
// Method to find the kth largest no in given BST
public virtual void kthLargest( int k)
{
count c = new count( this ); // object of class count
this .kthLargestUtil( this .root, k, 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);
for ( int i = 1; i <= 7; i++)
{
tree.kthLargest(i);
}
}
} // This code is contributed by Shrikant13
|
<script> // javascript code to find k'th largest element in BST // A binary tree node class Node { constructor(d)
{
this .data = d;
this .left = this .right = null ;
}
} // Root of BST
var root = null ;
// Constructor
// function to insert nodes
function insert(data)
{
this .root = this .insertRec( this .root, data);
}
/* A utility function to insert a new node
with given key in BST */
function insertRec( node , data)
{
/* If the tree is empty, return a new node */
if (node == null ) {
this .root = new Node(data);
return this .root;
}
if (data == node.data) {
return node;
}
/* 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
class count {
constructor(){ this .c = 0;}
}
// utility function to find kth largest no in
// a given tree
function kthLargestUtil( node , k, C)
{
// Base cases, the second condition is important to
// avoid unnecessary recursive calls
if (node == null || C.c >= k)
return ;
// Follow reverse inorder traversal so that the
// largest element is visited first
this .kthLargestUtil(node.right, k, C);
// Increment count of visited nodes
C.c++;
// If c becomes k now, then this is the k'th largest
if (C.c == k) {
document.write(k + "th largest element is " +
node.data+ "<br/>" );
return ;
}
// Recur for left subtree
this .kthLargestUtil(node.left, k, C);
}
// Method to find the kth largest no in given BST
function kthLargest(k)
{
c = new count(); // object of class count
this .kthLargestUtil( this .root, k, c);
}
// Driver function
/* Let us create following BST
50
/ \
30 70
/ \ / \
20 40 60 80 */
insert(50);
insert(30);
insert(20);
insert(40);
insert(70);
insert(60);
insert(80);
for (i = 1; i <= 7; i++) {
kthLargest(i);
}
// This code contributed by gauravrajput1 </script> |
K'th largest element is 80 K'th largest element is 70 K'th largest element is 60 K'th largest element is 50 K'th largest element is 40 K'th largest element is 30 K'th largest element is 20
Complexity Analysis:
-
Time Complexity: O(n).
In worst case the code can traverse each and every node of the tree if the k given is equal to n (total number of nodes in the tree). Therefore overall time complexity is O(n). -
Auxiliary Space: O(h).
Max recursion stack of height h at a given time.
This article is contributed by Chirag Sharma.
Approach 2:- Iterative approach
The idea is to do reverse inorder traversal of BST. Keep a count of nodes visited.
The reverse inorder traversal traverses all nodes in decreasing order, i.e, visit the right node then centre then left and continue traversing the nodes recursively.
While doing the traversal, keep track of the count of nodes visited so far.
When the count becomes equal to k, stop the traversal and print the key.
Time Complexity : – O(N)
#include <iostream> #include <stack> using namespace std;
struct TreeNode {
int val;
TreeNode *left;
TreeNode *right;
TreeNode( int x) : val(x), left(NULL), right(NULL) {}
}; int kthLargest(TreeNode* root, int k) {
stack<TreeNode*> st;
TreeNode* curr = root;
int count = 0;
while (curr != NULL || !st.empty()) {
while (curr != NULL) {
st.push(curr);
curr = curr->right;
}
curr = st.top();
st.pop();
count++;
if (count == k) {
return curr->val;
}
curr = curr->left;
}
return -1; // kth largest element does not exist
} int main() {
// create a BST
TreeNode* root = new TreeNode(5);
root->left = new TreeNode(3);
root->right = new TreeNode(7);
root->left->left = new TreeNode(2);
root->left->right = new TreeNode(4);
root->right->left = new TreeNode(6);
root->right->right = new TreeNode(8);
// find the kth largest element
int k = 3;
int kth_largest = kthLargest(root, k);
if (kth_largest != -1) {
cout << "The " << k << "th largest element is: " << kth_largest << endl;
} else {
cout << "The " << k << "th largest element does not exist" << endl;
}
return 0;
} |
import java.util.Stack;
// Creating Tree class TreeNode {
int val;
TreeNode left;
TreeNode right;
public TreeNode( int x) {
val = x;
left = null ;
right = null ;
}
} // Function to find kth largest element class KthLargestElementBST {
public static int kthLargest(TreeNode root, int k) {
Stack<TreeNode> stack = new Stack<>();
TreeNode curr = root;
int count = 0 ;
while (curr != null || !stack.empty()) {
while (curr != null ) {
stack.push(curr);
curr = curr.right;
}
curr = stack.pop();
count++;
if (count == k) {
return curr.val;
}
curr = curr.left;
}
return - 1 ; // kth largest element does not exist
}
// Driver code
public static void main(String[] args) {
// create a BST
TreeNode root = new TreeNode( 5 );
root.left = new TreeNode( 3 );
root.right = new TreeNode( 7 );
root.left.left = new TreeNode( 2 );
root.left.right = new TreeNode( 4 );
root.right.left = new TreeNode( 6 );
root.right.right = new TreeNode( 8 );
// find the kth largest element
int k = 3 ;
int kth_largest = kthLargest(root, k);
if (kth_largest != - 1 ) {
System.out.println( "The " + k + "th largest element is: " + kth_largest);
} else {
System.out.println( "The " + k + "th largest element does not exist" );
}
}
} |
class TreeNode:
def __init__( self , x):
self .val = x
self .left = None
self .right = None
def kthLargest(root: TreeNode, k: int ) - > int :
st = []
curr = root
count = 0
while curr or st:
while curr:
st.append(curr)
curr = curr.right
curr = st.pop()
count + = 1
if count = = k:
return curr.val
curr = curr.left
return - 1
# create a BST root = TreeNode( 5 )
root.left = TreeNode( 3 )
root.right = TreeNode( 7 )
root.left.left = TreeNode( 2 )
root.left.right = TreeNode( 4 )
root.right.left = TreeNode( 6 )
root.right.right = TreeNode( 8 )
# find the kth largest element k = 3
kth_largest = kthLargest(root, k)
if kth_largest ! = - 1 :
print (f "The {k}th largest element is: {kth_largest}" )
else :
print (f "The {k}th largest element does not exist" )
|
using System;
using System.Collections.Generic;
public class TreeNode {
public int val;
public TreeNode left;
public TreeNode right;
public TreeNode( int x)
{
val = x;
left = null ;
right = null ;
}
} public class KthLargestElementBST {
// Function to find kth largest element
public static int KthLargest(TreeNode root, int k)
{
Stack<TreeNode> stack = new Stack<TreeNode>();
TreeNode curr = root;
int count = 0;
while (curr != null || stack.Count > 0) {
while (curr != null ) {
stack.Push(curr);
curr = curr.right;
}
curr = stack.Pop();
count++;
if (count == k) {
return curr.val;
}
curr = curr.left;
}
return -1; // kth largest element does not exist
}
// Driver code
public static void Main()
{
// create a BST
TreeNode root = new TreeNode(5);
root.left = new TreeNode(3);
root.right = new TreeNode(7);
root.left.left = new TreeNode(2);
root.left.right = new TreeNode(4);
root.right.left = new TreeNode(6);
root.right.right = new TreeNode(8);
// find the kth largest element
int k = 3;
int kth_largest = KthLargest(root, k);
if (kth_largest != -1) {
Console.WriteLine( "The " + k
+ "th largest element is: "
+ kth_largest);
}
else {
Console.WriteLine(
"The " + k
+ "th largest element does not exist" );
}
}
} |
class TreeNode { constructor(x) {
this .val = x;
this .left = null ;
this .right = null ;
}
} function kthLargest(root, k) {
const st = [];
let curr = root;
let count = 0;
while (curr || st.length) {
while (curr) {
st.push(curr);
curr = curr.right;
}
curr = st.pop();
count++;
if (count === k) {
return curr.val;
}
curr = curr.left;
}
return -1;
} // create a BST const root = new TreeNode(5);
root.left = new TreeNode(3);
root.right = new TreeNode(7);
root.left.left = new TreeNode(2);
root.left.right = new TreeNode(4);
root.right.left = new TreeNode(6);
root.right.right = new TreeNode(8);
// find the kth largest element const k = 3; const kth_largest = kthLargest(root, k); if (kth_largest !== -1) {
console.log(`The ${k}th largest element is: ${kth_largest}`);
} else {
console.log(`The ${k}th largest element does not exist`);
} |
The 3th largest element is: 6
Time complexity –The time complexity of the kthLargest function is O(h + k), where h is the height of the binary search tree and k is the given value for finding the kth largest element. This is because in the worst case, the function will need to traverse the height of the tree and then traverse k elements to find the kth largest element.
Space complexity –The space complexity of the kthLargest function is O(h), where h is the height of the binary search tree. This is because the function uses a stack to store the nodes in the right subtree, which can have at most h nodes if the tree is skewed.
Using a Max Heap:
Follow the steps to implement the above approach:
- Create an empty max heap of integers using the C++ STL priority_queue container.
- Traverse the binary search tree in reverse in-order sequence using a stack.
- At each node, add the node value to the max heap.
- If the size of the max heap becomes greater than K, remove the maximum element from the max heap.
- After we finish traversing the binary search tree, the maximum element in the max heap will be the Kth largest element in the binary search tree.
Below is the implementation of the above approach:
// C++ code to implement maxHeap approach #include <bits/stdc++.h> using namespace std;
// Definition of a binary tree node struct Node {
int data;
Node *left, *right;
Node( int val)
{
data = val;
left = right = NULL;
}
}; // Function to implement maxHeap approach int kthLargest(Node* root, int K)
{ priority_queue< int > maxHeap;
// Traverse the binary search tree and add elements to
// the max heap
stack<Node*> s;
Node* curr = root;
while (curr != NULL || s.empty() == false ) {
while (curr != NULL) {
s.push(curr);
curr = curr->right;
}
curr = s.top();
s.pop();
maxHeap.push(curr->data);
curr = curr->left;
}
// Remove K-1 elements from the max heap
for ( int i = 1; i < K; i++) {
maxHeap.pop();
}
// The top element of the max heap is the Kth largest
// element
return maxHeap.top();
} // Driver Code int main()
{ // Example binary search tree
/*
4
/ \
2 9
/ \
7 10
*/
Node* root = new Node(4);
root->left = new Node(2);
root->right = new Node(9);
root->right->left = new Node(7);
root->right->right = new Node(10);
int K = 2;
int kthLargestElement = kthLargest(root, K);
cout << "The " << K
<< "th largest element in the binary search tree "
"is: "
<< kthLargestElement << endl;
return 0;
} // This code is contributed by Veerendra_Singh_Rajpoot |
import java.util.PriorityQueue;
import java.util.Stack;
// Definition of a binary tree node class Node {
int data;
Node left, right;
Node( int val) {
data = val;
left = right = null ;
}
} public class KthLargestElement {
// Function to implement maxHeap approach to find the Kth largest element
public static int kthLargest(Node root, int K) {
// Create a max heap to store the largest elements
PriorityQueue<Integer> maxHeap = new PriorityQueue<>((a, b) -> b - a);
// Traverse the binary search tree and add elements to the max heap
Stack<Node> stack = new Stack<>();
Node curr = root;
while (curr != null || !stack.isEmpty()) {
while (curr != null ) {
stack.push(curr);
curr = curr.right;
}
curr = stack.pop();
maxHeap.add(curr.data);
curr = curr.left;
}
// Remove K-1 elements from the max heap
for ( int i = 1 ; i < K; i++) {
maxHeap.poll();
}
// The top element of the max heap is the Kth largest element
return maxHeap.peek();
}
// Driver Code
public static void main(String[] args) {
// Example binary search tree
/*
4
/ \
2 9
/ \
7 10
*/
Node root = new Node( 4 );
root.left = new Node( 2 );
root.right = new Node( 9 );
root.right.left = new Node( 7 );
root.right.right = new Node( 10 );
int K = 2 ;
int kthLargestElement = kthLargest(root, K);
System.out.println( "The " + K + "th largest element in the binary search tree is: " + kthLargestElement);
}
} |
import heapq
# Definition of a binary tree node class Node:
def __init__( self , val):
self .data = val
self .left = None
self .right = None
# Function to implement maxHeap approach def kthLargest(root, K):
maxHeap = []
# Traverse the binary search tree and add elements to
# the max heap
stack = []
curr = root
while curr or stack:
while curr:
stack.append(curr)
curr = curr.right
curr = stack.pop()
heapq.heappush(maxHeap, - curr.data)
curr = curr.left
# Remove K-1 elements from the max heap
for i in range (K - 1 ):
heapq.heappop(maxHeap)
# The top element of the max heap is the Kth largest
# element
return - maxHeap[ 0 ]
# Driver Code if __name__ = = '__main__' :
# Example binary search tree
'''
4
/ \
2 9
/ \
7 10
'''
root = Node( 4 )
root.left = Node( 2 )
root.right = Node( 9 )
root.right.left = Node( 7 )
root.right.right = Node( 10 )
K = 2
kthLargestElement = kthLargest(root, K)
print (f "The {K}th largest element in the binary search tree is: {kthLargestElement}" )
|
// C# code to implement maxHeap approach using System;
using System.Collections.Generic;
// Definition of a binary tree node class Node
{ public int Data;
public Node Left, Right;
public Node( int val)
{
Data = val;
Left = Right = null ;
}
} class GFG
{ // Function to implement maxHeap approach
static int KthLargest(Node root, int K)
{
// Create a max heap
List< int > maxHeap = new List< int >();
// Traverse the binary search tree and add elements to the max heap
Stack<Node> stack = new Stack<Node>();
Node curr = root;
while (curr != null || stack.Count > 0)
{
while (curr != null )
{
stack.Push(curr);
curr = curr.Right;
}
curr = stack.Pop();
maxHeap.Add(curr.Data);
curr = curr.Left;
}
// Sort the max heap in descending order
maxHeap.Sort((x, y) => y.CompareTo(x));
// The Kth largest element is at index K-1
return maxHeap[K - 1];
}
// Driver Code
static void Main( string [] args)
{
// Example binary search tree
/*
4
/ \
2 9
/ \
7 10
*/
Node root = new Node(4);
root.Left = new Node(2);
root.Right = new Node(9);
root.Right.Left = new Node(7);
root.Right.Right = new Node(10);
int K = 2;
int kthLargestElement = KthLargest(root, K);
Console.WriteLine( "The " + K + "th largest element in the binary search tree is: " + kthLargestElement);
}
} // This code is contributed by Susobhan Akhuli |
// Definition of a binary tree node class Node { constructor(val) {
this .data = val;
this .left = null ;
this .right = null ;
}
} // Function to implement maxHeap approach function kthLargest(root, K) {
const maxHeap = new MaxHeap();
// Traverse the binary search tree and add elements to the max heap
const stack = [];
let curr = root;
while (curr !== null || stack.length > 0) {
while (curr !== null ) {
stack.push(curr);
curr = curr.right;
}
curr = stack.pop();
maxHeap.push(curr.data);
curr = curr.left;
}
// Remove K-1 elements from the max heap
for (let i = 1; i < K; i++) {
maxHeap.pop();
}
// The top element of the max heap is the Kth largest element
return maxHeap.top();
} // MaxHeap implementation class MaxHeap { constructor() {
this .heap = [];
}
push(val) {
this .heap.push(val);
this .heapifyUp( this .heap.length - 1);
}
pop() {
if ( this .heap.length === 0) {
return null ;
}
if ( this .heap.length === 1) {
return this .heap.pop();
}
const root = this .heap[0];
this .heap[0] = this .heap.pop();
this .heapifyDown(0);
return root;
}
top() {
if ( this .heap.length === 0) {
return null ;
}
return this .heap[0];
}
heapifyUp(index) {
while (index > 0) {
const parentIndex = Math.floor((index - 1) / 2);
if ( this .heap[index] <= this .heap[parentIndex]) {
break ;
}
[ this .heap[index], this .heap[parentIndex]] = [ this .heap[parentIndex], this .heap[index]];
index = parentIndex;
}
}
heapifyDown(index) {
while ( true ) {
const leftChildIndex = 2 * index + 1;
const rightChildIndex = 2 * index + 2;
let largestIndex = index;
if (leftChildIndex < this .heap.length && this .heap[leftChildIndex] >
this .heap[largestIndex]) {
largestIndex = leftChildIndex;
}
if (rightChildIndex < this .heap.length && this .heap[rightChildIndex] >
this .heap[largestIndex]) {
largestIndex = rightChildIndex;
}
if (largestIndex === index) {
break ;
}
[ this .heap[index], this .heap[largestIndex]] =
[ this .heap[largestIndex], this .heap[index]];
index = largestIndex;
}
}
} // Driver Code // Example binary search tree /* 4
/ \
2 9
/ \
7 10
*/ const root = new Node(4);
root.left = new Node(2);
root.right = new Node(9);
root.right.left = new Node(7);
root.right.right = new Node(10);
const K = 2; const kthLargestElement = kthLargest(root, K); console.log(`The ${K}th largest element in the binary search tree is: ${kthLargestElement}`);
// This code is contributed by Veerendra_Singh_Rajpoot |
The 2th largest element in the binary search tree is: 9
Time Complexity: O(n logk) , The worst-case time complexity of building a max heap of size k is O(klogk).
The worst-case time complexity of traversing a binary search tree in reverse in-order sequence is O(n), where n is the number of nodes in the binary search tree.
Space Complexity: O(k), We use a max heap of size k to keep track of the k largest elements in the binary search tree.
Therefore, the overall space complexity of this approach is O(k).