Find Kth largest number in a given Binary Tree

Last Updated : 21 Oct, 2024

Given a Binary Tree consisting of n nodes and a positive integer k, the task is to find the k^th largest number in the given tree.
Examples:

Input: k = 3

Output: 5
Explanation: The third largest element in the given binary tree is 5.

Input: k = 1

Output: 20
Explanation: The first largest element in the given binary tree is 20.

The simple approach to solve this question is to store the nodes of the given binary tree in an array and then sort this array. return the kth largest number from this sorted array.

Approach:

The above approach can be made efficient by ball 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. Then return the K^th largest element in the priority queue.

Below is the implementation of the above approach:

C++

// C++ program to find kth largest // number in a binary tree. #include <bits/stdc++.h> using namespace std;  class Node { public:     int data;     Node* left, *right;     Node (int x) {         data = x;         left = nullptr;         right = nullptr;     } };  // Function to store node values into // priority queue. void storeNodes(Node* root, priority_queue<int, vector<int>,                  greater<int>> &pq, int k) {     if (root == nullptr) return;          // If size of pq is less than k, or the top      // element of pq is less than root node.     if (pq.size() < k || root->data > pq.top()) {         if (pq.size() == k) pq.pop();         pq.push(root->data);     }              storeNodes(root->left, pq, k);     storeNodes(root->right, pq, k); }  // Function to find kth largest number int kthLargest(Node* root, int k) {          // store the values into priority_queue.     priority_queue<int, vector<int>, greater<int>> pq;     storeNodes(root, pq, k);          // If size of tree is less than k.     if (k>pq.size()) {         return -1;     }          return pq.top(); }  int main() {          // Construct the following binary tree     //             5     //           /   \     //         1      2     //       /  \    /     //      0    4  3        Node *root = new Node(5);     root->left = new Node(1);     root->right = new Node(2);     root->left->left = new Node(0);     root->left->right = new Node(4);     root->right->left = new Node(3);      int k = 3;     cout << kthLargest(root, k) << endl;      return 0; }

Java

// Java program to find kth largest // number in a binary tree. import java.util.ArrayList; import java.util.PriorityQueue;  class Node {     int data;     Node left, right;      Node(int x) {         data = x;         left = null;         right = null;     } }  class GfG {          // Function to store node values into     // priority queue.     static void storeNodes(Node root, 					PriorityQueue<Integer> pq, int k) {         if (root == null) return;                  // If size of pq is less than k, or the top          // element of pq is less than root node.         if (pq.size() < k || root.data > pq.peek()) {             if (pq.size() == k) pq.poll();             pq.offer(root.data);         }                  storeNodes(root.left, pq, k);         storeNodes(root.right, pq, k);     }      // Function to find kth largest number     static int kthLargest(Node root, int k) {                  // store the values into        	// priority_queue.         PriorityQueue<Integer> pq = new PriorityQueue<>();         storeNodes(root, pq, k);                  // If size of tree is less than k.         if (k > pq.size()) {             return -1;         }                  return pq.peek();     }      public static void main(String[] args) {                  // Construct the following binary tree         //             5         //           /   \         //         1      2         //       /  \    /         //      0    4  3            Node root = new Node(5);         root.left = new Node(1);         root.right = new Node(2);         root.left.left = new Node(0);         root.left.right = new Node(4);         root.right.left = new Node(3);          int k = 3;         System.out.println(kthLargest(root, k));     } }

Python

# Python program to find kth largest # number in a binary tree. import heapq  class Node:     def __init__(self, x):         self.data = x         self.left = None         self.right = None  # Function to store node values into # priority queue. def storeNodes(root, pq, k):     if root is None:         return          # If size of pq is less than k, or the top      # element of pq is less than root node.     if len(pq) < k or root.data > pq[0]:         if len(pq) == k:             heapq.heappop(pq)         heapq.heappush(pq, root.data)          storeNodes(root.left, pq, k)     storeNodes(root.right, pq, k)  # Function to find kth largest number def kthLargest(root, k):          # store the values into priority_queue.     pq = []     storeNodes(root, pq, k)          # If size of tree is less than k.     if k > len(pq):         return -1          return pq[0]  if __name__ == "__main__":          # Construct the following binary tree     #             5     #           /   \     #         1      2     #       /  \    /     #      0    4  3        root = Node(5)     root.left = Node(1)     root.right = Node(2)     root.left.left = Node(0)     root.left.right = Node(4)     root.right.left = Node(3)      k = 3     print(kthLargest(root, k))

// C# program to find kth largest // number in a binary tree. using System; using System.Collections.Generic;  class Node {     public int Data;     public Node Left, Right;      public Node(int x) {         Data = x;         Left = null;         Right = null;     } }  class GfG {      // Function to store node values into a list.     static void StoreNodes(Node root, List<int> values, int k) {         if (root == null) return;          values.Add(root.Data);         StoreNodes(root.Left, values, k);         StoreNodes(root.Right, values, k);     }      // Function to find the kth largest number     static int KthLargest(Node root, int k) {         List<int> values = new List<int>();         StoreNodes(root, values, k);          // Sort the list in descending order         values.Sort((a, b) => b.CompareTo(a));          // If size of tree is less than k.         if (k > values.Count) {             return -1;         }          return values[k - 1];     }      static void Main(string[] args) {                // Construct the following binary tree         //             5         //           /   \         //         1      2         //       /  \    /         //      0    4  3            Node root = new Node(5);         root.Left = new Node(1);         root.Right = new Node(2);         root.Left.Left = new Node(0);         root.Left.Right = new Node(4);         root.Right.Left = new Node(3);          int k = 3;         Console.WriteLine(KthLargest(root, k));     } }

JavaScript

// JavaScript program to find kth largest // number in a binary tree. class Node {     constructor(x) {         this.data = x;         this.left = null;         this.right = null;     } }  // Function to store node values into // priority queue. function storeNodes(root, pq, k) {     if (root === null) return;          // If size of pq is less than k, or the top      // element of pq is less than root node.     if (pq.length < k || root.data > pq[0]) {         if (pq.length === k) pq.shift();         pq.push(root.data);         pq.sort((a, b) => a - b);     }          storeNodes(root.left, pq, k);     storeNodes(root.right, pq, k); }  // Function to find kth largest number function kthLargest(root, k) {          // store the values into priority_queue.     const pq = [];     storeNodes(root, pq, k);          // If size of tree is less than k.     if (k > pq.length) {         return -1;     }          return pq[0];  }      // Construct the following binary tree //             5 //           /   \ //         1      2 //       /  \    / //      0    4  3    const root = new Node(5); root.left = new Node(1); root.right = new Node(2); root.left.left = new Node(0); root.left.right = new Node(4); root.right.left = new Node(3);  const k = 3; console.log(kthLargest(root, k));

Output

Time Complexity: O(nlogk), Inserting an element into a priority queue takes O(log k) time. Thus, for n nodes, the overall time complexity becomes O(n log k).
Auxiliary Space: O(max(h,k)) , where h is the height of the binary tree.

Find the largest Perfect Subtree in a given Binary Tree

namanaggarwal1

Improve

Article Tags :

Practice Tags :

Find Kth largest number in a given Binary Tree

Similar Reads