Find Kth largest number in a given Binary Tree

• Last Updated : 24 Aug, 2021

Given a Binary Tree consisting of N nodes and a positive integer K, the task is to find the Kth largest number in the given tree.
Examples:

Input: K = 3
1
/    \
2        3
/  \       /  \
4     5    6    7
Output: 5
Explanation: The third largest element in the given binary tree is 5.

Input: K = 1
1
/    \
2        3
Output: 1
Explanation: The first largest element in the given binary tree is 1.

Naive Approach: Flatten the given binary tree and then sort the array. Print the Kth largest number from this sorted array now.

Efficient Approach: The above approach can be made efficient by storing all the elements of the Tree in a priority queue, as the elements are stored based on the priority order, which is ascending by default. Though the complexity will remain the same as the above approach, here we can avoid the additional sorting step.
Just print the Kth largest element in the priority queue

Below is the implementation of the above approach:

C++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `// Struct binary tree node` `struct` `Node {` `    ``int` `data;` `    ``Node *left, *right;` `};`   `// Function to create a new node of` `// the tree` `Node* newNode(``int` `data)` `{` `    ``Node* temp = ``new` `Node();` `    ``temp->data = data;` `    ``temp->left = temp->right = NULL;` `    ``return` `temp;` `}`   `// Utility function to find the Kth` `// largest element in the given tree` `int` `findKthLargest(priority_queue<``int``,` `                                  ``vector<``int``> >& pq,` `                   ``int` `k)` `{` `    ``// Loop until priority queue is not` `    ``// empty and K greater than 0` `    ``while` `(--k && !pq.empty()) {` `        ``pq.pop();` `    ``}`   `    ``// If PQ is not empty then return` `    ``// the top element` `    ``if` `(!pq.empty()) {` `        ``return` `pq.top();` `    ``}`   `    ``// Otherwise, return -1` `    ``return` `-1;` `}`   `// Function to traverse the given` `// binary tree` `void` `traverse(` `    ``Node* root, priority_queue<``int``,` `                               ``vector<``int``> >& pq)` `{`   `    ``if` `(!root) {` `        ``return``;` `    ``}`   `    ``// Pushing values in binary tree` `    ``pq.push(root->data);`   `    ``// Left and Right Recursive Call` `    ``traverse(root->left, pq);` `    ``traverse(root->right, pq);` `}`   `// Function to find the Kth largest` `// element in the given tree` `void` `findKthLargestTree(Node* root, ``int` `K)` `{`   `    ``// Stores all elements tree in PQ` `    ``priority_queue<``int``, vector<``int``> > pq;`   `    ``// Function Call` `    ``traverse(root, pq);`   `    ``// Function Call` `    ``cout << findKthLargest(pq, K);` `}`   `// Driver Code` `int` `main()` `{` `    ``// Given Input` `    ``Node* root = newNode(1);` `    ``root->left = newNode(2);` `    ``root->left->left = newNode(4);` `    ``root->left->right = newNode(5);` `    ``root->right = newNode(3);` `    ``root->right->right = newNode(7);` `    ``root->right->left = newNode(6);` `    ``int` `K = 3;`   `    ``findKthLargestTree(root, K);`   `    ``return` `0;` `}`

Java

 `// Java program for the above approach` `import` `java.util.*;` `public` `class` `Main` `{` `  `  `    ``// Struct binary tree node` `    ``static` `class` `Node` `    ``{` `        ``int` `data;` `        ``Node left;` `        ``Node right;` `    ``}` `    `  `    ``// Function to create new node of the tree` `    ``static` `Node newNode(``int` `data)` `    ``{` `        ``Node temp = ``new` `Node();` `        ``temp.data = data;` `        ``temp.left = ``null``;` `        ``temp.right = ``null``;` `        ``return` `temp;` `    ``}` `    `  `    ``// Stores all elements tree in PQ` `    ``static` `Vector pq = ``new` `Vector();` `     `  `    ``// Utility function to find the Kth` `    ``// largest element in the given tree` `    ``static` `int` `findKthLargest(``int` `k)` `    ``{` `        ``// Loop until priority queue is not` `        ``// empty and K greater than 0` `        ``--k;` `        ``while` `(k > ``0` `&& pq.size() > ``0``) {` `            ``pq.remove(``0``);` `            ``--k;` `        ``}` `       `  `        ``// If PQ is not empty then return` `        ``// the top element` `        ``if` `(pq.size() > ``0``) {` `            ``return` `pq.get(``0``);` `        ``}` `       `  `        ``// Otherwise, return -1` `        ``return` `-``1``;` `    ``}` `       `  `    ``// Function to traverse the given` `    ``// binary tree` `    ``static` `void` `traverse(Node root)` `    ``{` `       `  `        ``if` `(root == ``null``) {` `            ``return``;` `        ``}` `       `  `        ``// Pushing values in binary tree` `        ``pq.add(root.data);` `        ``Collections.sort(pq);` `        ``Collections.reverse(pq);` `       `  `        ``// Left and Right Recursive Call` `        ``traverse(root.left);` `        ``traverse(root.right);` `    ``}` `       `  `    ``// Function to find the Kth largest` `    ``// element in the given tree` `    ``static` `void` `findKthLargestTree(Node root, ``int` `K)` `    ``{` `        ``// Function Call` `        ``traverse(root);` `       `  `        ``// Function Call` `        ``System.out.print(findKthLargest(K));` `    ``}`   `  ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `      `  `        ``// Given Input` `        ``Node root = newNode(``1``);` `        ``root.left = newNode(``2``);` `        ``root.left.left = newNode(``4``);` `        ``root.left.right = newNode(``5``);` `        ``root.right = newNode(``3``);` `        ``root.right.right = newNode(``7``);` `        ``root.right.left = newNode(``6``);` `        ``int` `K = ``3``;` `       `  `        ``findKthLargestTree(root, K);` `    ``}` `}`   `// This code is contributed by divyesh07.`

Python3

 `# Python3 program for the above approach` `class` `Node:` `    ``# Struct binary tree node` `    ``def` `__init__(``self``, data):` `        ``self``.data ``=` `data` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None`   `# Stores all elements tree in PQ` `pq ``=` `[]` `  `  `# Utility function to find the Kth` `# largest element in the given tree` `def` `findKthLargest(k):` `    ``# Loop until priority queue is not` `    ``# empty and K greater than 0` `    ``k``-``=``1` `    ``while` `(k > ``0` `and` `len``(pq) > ``0``):` `        ``pq.pop(``0``)` `        ``k``-``=``1` `    `  `    ``# If PQ is not empty then return` `    ``# the top element` `    ``if` `len``(pq) > ``0``:` `        ``return` `pq[``0``]` `    `  `    ``# Otherwise, return -1` `    ``return` `-``1` `    `  `# Function to traverse the given` `# binary tree` `def` `traverse(root):` `    ``if` `(root ``=``=` `None``):` `        ``return` `    `  `    ``# Pushing values in binary tree` `    ``pq.append(root.data)` `    ``pq.sort()` `    ``pq.reverse()` `    `  `    ``# Left and Right Recursive Call` `    ``traverse(root.left)` `    ``traverse(root.right)` `    `  `# Function to find the Kth largest` `# element in the given tree` `def` `findKthLargestTree(root, K):` `    ``# Function Call` `    ``traverse(root);` `    `  `    ``# Function Call` `    ``print``(findKthLargest(K))`   `# Given Input` `root ``=` `Node(``1``)` `root.left ``=` `Node(``2``)` `root.left.left ``=` `Node(``4``)` `root.left.right ``=` `Node(``5``)` `root.right ``=` `Node(``3``)` `root.right.right ``=` `Node(``7``)` `root.right.left ``=` `Node(``6``)` `K ``=` `3`   `findKthLargestTree(root, K)`   `# This code is contributed by mukesh07.`

C#

 `// C# program for the above approach` `using` `System;` `using` `System.Collections.Generic;` `class` `GFG {` `    `  `    ``// Struct binary tree node` `    ``class` `Node` `    ``{` `        ``public` `int` `data;` `        ``public` `Node left, right;` `    ``};` `    `  `    ``// Function to create a new node of the tree` `    ``static` `Node newNode(``int` `data)` `    ``{` `      ``Node temp = ``new` `Node();` `      ``temp.data = data;` `      ``temp.left = ``null``;` `      ``temp.right = ``null``;` `      ``return` `temp;` `    ``}` `    `  `    ``// Stores all elements tree in PQ` `    ``static` `List<``int``> pq = ``new` `List<``int``>();` `    `  `    ``// Utility function to find the Kth` `    ``// largest element in the given tree` `    ``static` `int` `findKthLargest(``int` `k)` `    ``{` `        ``// Loop until priority queue is not` `        ``// empty and K greater than 0` `        ``--k;` `        ``while` `(k > 0 && pq.Count > 0) {` `            ``pq.RemoveAt(0);` `            ``--k;` `        ``}` `      `  `        ``// If PQ is not empty then return` `        ``// the top element` `        ``if` `(pq.Count > 0) {` `            ``return` `pq[0];` `        ``}` `      `  `        ``// Otherwise, return -1` `        ``return` `-1;` `    ``}` `      `  `    ``// Function to traverse the given` `    ``// binary tree` `    ``static` `void` `traverse(Node root)` `    ``{` `      `  `        ``if` `(root == ``null``) {` `            ``return``;` `        ``}` `      `  `        ``// Pushing values in binary tree` `        ``pq.Add(root.data);` `        ``pq.Sort();` `        ``pq.Reverse();` `      `  `        ``// Left and Right Recursive Call` `        ``traverse(root.left);` `        ``traverse(root.right);` `    ``}` `      `  `    ``// Function to find the Kth largest` `    ``// element in the given tree` `    ``static` `void` `findKthLargestTree(Node root, ``int` `K)` `    ``{` `        ``// Function Call` `        ``traverse(root);` `      `  `        ``// Function Call` `        ``Console.Write(findKthLargest(K));` `    ``}`   `  ``static` `void` `Main() {` `    ``// Given Input` `    ``Node root = newNode(1);` `    ``root.left = newNode(2);` `    ``root.left.left = newNode(4);` `    ``root.left.right = newNode(5);` `    ``root.right = newNode(3);` `    ``root.right.right = newNode(7);` `    ``root.right.left = newNode(6);` `    ``int` `K = 3;` `  `  `    ``findKthLargestTree(root, K);` `  ``}` `}`   `// This code is contributed by divyeshrabadiya07.`

Javascript

 ``

Output:

`5`

Time Complexity: O((N + K)log N)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up
Recommended Articles
Page :