Given a BST, the task is to find the sum of all elements greater than and equal to kth largest element.
Examples:
Input : K = 3 8 / \ 7 10 / / \ 2 9 13 Output : 32 Explanation: 3rd largest element is 9 so sum of all elements greater than or equal to 9 are 9 + 10 + 13 = 32. Input : K = 2 8 / \ 5 11 / \ 2 7 \ 3 Output : 19 Explanation: 2nd largest element is 8 so sum of all elements greater than or equal to 8 are 8 + 11 = 19.
Approach:
The idea is to traverse BST in Inorder traversal in a reverse way (Right Root Left).
Note that Inorder traversal of BST accesses elements in a sorted (or increasing) order, hence the reverse of inorder traversal will be in a sorted order(decreasing). While traversing, keep track of the count of visited Nodes and keep adding Nodes until the count becomes k.
C++
// C++ program to find Sum Of All Elements larger // than or equal to Kth Largest Element In BST #include <bits/stdc++.h> using namespace std;
struct Node {
int data;
Node *left, *right;
}; // utility function new Node of BST struct Node* cNode( int data)
{ Node* node = new Node;
node->left = NULL;
node->right = NULL;
node->data = data;
return node;
} // A utility function to insert a new Node // with given key in BST struct Node* add(Node* root, int key)
{ // If the tree is empty, return a new Node
if (root == NULL)
return cNode(key);
// Otherwise, recur down the tree
if (root->data > key)
root->left = add(root->left, key);
else if (root->data < key)
root->right = add(root->right, key);
// return the (unchanged) Node pointer
return root;
} // function to return sum of all elements larger than // and equal to Kth largest element int klargestElementSumUtil(Node* root, int k, int & c)
{ // Base cases
if (root == NULL)
return 0;
if (c > k)
return 0;
// Compute sum of elements in right subtree
int ans = klargestElementSumUtil(root->right, k, c);
if (c >= k)
return ans;
// Add root's data
ans += root->data;
// Add current Node
c++;
if (c >= k)
return ans;
// If c is less than k, return left subtree Nodes
return ans + klargestElementSumUtil(root->left, k, c);
} // Wrapper over klargestElementSumRec() int klargestElementSum( struct Node* root, int k)
{ int c = 0;
klargestElementSumUtil(root, k, c);
} // Drivers code int main()
{ /* 19
/ \
7 21
/ \
3 11
/ \
9 13
*/
Node* root = NULL;
root = add(root, 19);
root = add(root, 7);
root = add(root, 3);
root = add(root, 11);
root = add(root, 9);
root = add(root, 13);
root = add(root, 21);
int k = 2;
cout << klargestElementSum(root, k) << endl;
return 0;
} |
Java
// Java program to find Sum Of All Elements larger // than or equal to Kth Largest Element In BST import java.util.*;
class GFG
{ static class Node
{ int data;
Node left, right;
}; static int c;
// Utility function new Node of BST static Node cNode( int data)
{ Node node = new Node();
node.left = null ;
node.right = null ;
node.data = data;
return node;
} // A utility function to insert a new Node // with given key in BST static Node add(Node root, int key)
{ // If the tree is empty, return a new Node
if (root == null )
return cNode(key);
// Otherwise, recur down the tree
if (root.data > key)
root.left = add(root.left, key);
else if (root.data < key)
root.right = add(root.right, key);
// return the (unchanged) Node pointer
return root;
} // function to return sum of all elements larger than // and equal to Kth largest element static int klargestElementSumUtil(Node root, int k)
{ // Base cases
if (root == null )
return 0 ;
if (c > k)
return 0 ;
// Compute sum of elements in right subtree
int ans = klargestElementSumUtil(root.right, k);
if (c >= k)
return ans;
// Add root's data
ans += root.data;
// Add current Node
c++;
if (c >= k)
return ans;
// If c is less than k, return left subtree Nodes
return ans + klargestElementSumUtil(root.left, k);
} // Wrapper over klargestElementSumRec() static int klargestElementSum(Node root, int k)
{ c = 0 ;
return klargestElementSumUtil(root, k);
} // Drivers code public static void main(String[] args)
{ /* 19
/ \
7 21
/ \
3 11
/ \
9 13
*/
Node root = null ;
root = add(root, 19 );
root = add(root, 7 );
root = add(root, 3 );
root = add(root, 11 );
root = add(root, 9 );
root = add(root, 13 );
root = add(root, 21 );
int k = 2 ;
System.out.print(klargestElementSum(root, k) + "\n" );
} } // This code is contributed by PrinciRaj1992 |
Python3
# Python3 program to find sum of all elements larger # than or equal to Kth largest element In BST c = 0
class cNode:
def __init__( self , data):
self .data = data
self .left = None
self .right = None
# A utility function to insert a new Node # with given key in BST def add(root, key):
# If the tree is empty, return a new Node
if (root = = None ):
return cNode(key)
# Otherwise, recur down the tree
if (root.data > key):
root.left = add(root.left, key)
elif (root.data < key):
root.right = add(root.right, key)
# return the (unchanged) Node pointer
return root
# Function to return sum of all elements # larger than and equal to Kth largest element def klargestElementSumUtil(root, k):
global c
# Base cases
if (root = = None ):
return 0
if (c > k):
return 0
# Compute sum of elements in right subtree
ans = klargestElementSumUtil(root.right, k)
if (c > = k):
return ans
# Add root's data
ans + = root.data
# Add current Node
c + = 1
if (c > = k):
return ans
# If c is less than k, return left subtree Nodes
return ans + klargestElementSumUtil(root.left, k)
# Wrapper over klargestElementSumRec() def klargestElementSum(root, k):
return klargestElementSumUtil(root, k)
# Driver code if __name__ = = '__main__' :
'''
/* 19
/ \
7 21
/ \
3 11
/ \
9 13
*/ '''
root = None
root = add(root, 19 )
root = add(root, 7 )
root = add(root, 3 )
root = add(root, 11 )
root = add(root, 9 )
root = add(root, 13 )
root = add(root, 21 )
k = 2
print (klargestElementSum(root, k))
# This code is contributed by bgangwar59 |
C#
// C# program to find Sum Of All Elements larger // than or equal to Kth Largest Element In BST using System;
class GFG
{ class Node
{ public int data;
public Node left, right;
}; static int c;
// Utility function new Node of BST static Node cNode( int data)
{ Node node = new Node();
node.left = null ;
node.right = null ;
node.data = data;
return node;
} // A utility function to insert a new Node // with given key in BST static Node add(Node root, int key)
{ // If the tree is empty, return a new Node
if (root == null )
return cNode(key);
// Otherwise, recur down the tree
if (root.data > key)
root.left = add(root.left, key);
else if (root.data < key)
root.right = add(root.right, key);
// return the (unchanged) Node pointer
return root;
} // function to return sum of all elements larger than // and equal to Kth largest element static int klargestElementSumUtil(Node root, int k)
{ // Base cases
if (root == null )
return 0;
if (c > k)
return 0;
// Compute sum of elements in right subtree
int ans = klargestElementSumUtil(root.right, k);
if (c >= k)
return ans;
// Add root's data
ans += root.data;
// Add current Node
c++;
if (c >= k)
return ans;
// If c is less than k, return left subtree Nodes
return ans + klargestElementSumUtil(root.left, k);
} // Wrapper over klargestElementSumRec() static int klargestElementSum(Node root, int k)
{ c = 0;
return klargestElementSumUtil(root, k);
} // Drivers code public static void Main(String[] args)
{ /* 19
/ \
7 21
/ \
3 11
/ \
9 13
*/
Node root = null ;
root = add(root, 19);
root = add(root, 7);
root = add(root, 3);
root = add(root, 11);
root = add(root, 9);
root = add(root, 13);
root = add(root, 21);
int k = 2;
Console.Write(klargestElementSum(root, k) + "\n" );
} } // This code is contributed by PrinciRaj1992 |
Javascript
<script> // Javascript program to find Sum // Of All Elements larger than or // equal to Kth Largest Element In BST class Node { constructor(data)
{
this .left = null ;
this .right = null ;
this .data = data;
}
} let c; // Utility function new Node of BST function cNode(data)
{ let node = new Node(data);
return node;
} // A utility function to insert a new Node // with given key in BST function add(root, key)
{ // If the tree is empty, return a new Node
if (root == null )
return cNode(key);
// Otherwise, recur down the tree
if (root.data > key)
root.left = add(root.left, key);
else if (root.data < key)
root.right = add(root.right, key);
// Return the (unchanged) Node pointer
return root;
} // Function to return sum of all elements // larger than and equal to Kth largest element function klargestElementSumUtil(root, k)
{ // Base cases
if (root == null )
return 0;
if (c > k)
return 0;
// Compute sum of elements in right subtree
let ans = klargestElementSumUtil(root.right, k);
if (c >= k)
return ans;
// Add root's data
ans += root.data;
// Add current Node
c++;
if (c >= k)
return ans;
// If c is less than k, return left subtree Nodes
return ans + klargestElementSumUtil(root.left, k);
} // Wrapper over klargestElementSumRec() function klargestElementSum(root, k)
{ c = 0;
return klargestElementSumUtil(root, k);
} // Driver code /* 19 / \
7 21 / \ 3 11 / \
9 13
*/
let root = null ;
root = add(root, 19); root = add(root, 7); root = add(root, 3); root = add(root, 11); root = add(root, 9); root = add(root, 13); root = add(root, 21); let k = 2; document.write( klargestElementSum(root, k) + "</br>" );
// This code is contributed by divyeshrabadiya07 </script> |
Output:
40
Recommended Articles