# Sum of K largest elements in BST using O(1) Extra space

Given a BST, the task is to find the sum of all elements greater than or equal to K-th largest element in O(1) space.

**Examples:**

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 approach here is to do reverse inorder traversal, and while doing it simply keep a count of the number of nodes visited. Until the count of visited nodes is less than equal to K, keep on adding the current node’s data. Use the fact that the reverse inorder traversal of a BST gives us a list which is sorted in decreasing order. But recursion or stack/queue based approach to do reverse inorder traversal because both these techniques consume **O(n)** extra memory, instead make use of Reverse Morris Traversal to do inorder tree traversal, which is a memory efficient and faster method to do reverse inorder tree traversal based on threaded binary trees.

Given below is the **algorithm:**

1) Initialize Current as root. 2) Initialize a "count" and "sum" variable to 0. 3) While current is not NULL : 3.1) If the current has no right child a) Increment count and check if count is less than or equal to K. 1) Simply add the current node's data in "sum" variable. b) Otherwise, Move to the left child of current. 3.2) Else, here we have 2 cases: a) Find the inorder successor of current Node. Inorder successor is the left most Node in the right subtree or right child itself. b) If the left child of the inorder successor is NULL: 1) Set current as the left child of its inorder successor. 2) Move current Node to its right child. c) Else, if the threaded link between the current Node and it's inorder successor already exists : 1) Set left pointer of the inorder successor as NULL. 2) Increment count and check if the count is less than or equal to K. 2.a) Simply add the current node's data in "sum" variable. 3) Otherwise, Move current to it's left child. 4)After the traversal is complete simply return the sum.

Below is the implementation of the above approach:

`// C++ program to find sum of ` `// K largest elements in BST using ` `// Reverse Morris Traversal ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `struct` `node { ` ` ` `int` `data; ` ` ` `struct` `node *left, *right; ` `}; ` ` ` `// Add a new node ` `node* newNode(` `int` `item) ` `{ ` ` ` `node* temp = ` `new` `node; ` ` ` `temp->data = item; ` ` ` `temp->left = temp->right = NULL; ` ` ` ` ` `return` `temp; ` `} ` ` ` `// Function to find the sum of the K largest elements ` `// space efficient method used ` `int` `SumKLargestUsingReverseMorrisTraversal(node* root, ` `int` `k) ` `{ ` ` ` `node* curr = root; ` ` ` `int` `sum = 0; ` ` ` `int` `count = 0; ` ` ` ` ` `// while doing reverse inorder traversal ` ` ` `// keep track of visited nodes ` ` ` `while` `(curr) { ` ` ` `if` `(curr->right == NULL) { ` ` ` ` ` `// till count is less than k ` ` ` `if` `(++count <= k) { ` ` ` `sum += curr->data; ` ` ` `} ` ` ` ` ` `curr = curr->left; ` ` ` `} ` ` ` ` ` `else` `{ ` ` ` `// finding the inorder successor node ` ` ` `// inorder successor is the left most in right subtree ` ` ` `node* succ = curr->right; ` ` ` `while` `(succ->left && succ->left != curr) ` ` ` `succ = succ->left; ` ` ` ` ` `if` `(succ->left == NULL) { ` ` ` `succ->left = curr; ` ` ` ` ` `curr = curr->right; ` ` ` `} ` ` ` ` ` `// if the threaded link already exists then simply ` ` ` `// revert back the tree to original form. ` ` ` `else` `{ ` ` ` `succ->left = NULL; ` ` ` ` ` `if` `(++count <= k) ` ` ` `sum += curr->data; ` ` ` ` ` `curr = curr->left; ` ` ` `} ` ` ` `} ` ` ` `} ` ` ` ` ` `return` `sum; ` `} ` ` ` `// Driver Code ` `int` `main() ` `{ ` ` ` `/* Constructed binary tree is ` ` ` `8 ` ` ` `/ \ ` ` ` `7 10 ` ` ` `/ / \ ` ` ` `2 9 13 ` `*/` ` ` ` ` `struct` `node* root = newNode(8); ` ` ` ` ` `root->right = newNode(10); ` ` ` `root->left = newNode(7); ` ` ` `root->left->left = newNode(2); ` ` ` ` ` `root->right->left = newNode(9); ` ` ` `root->right->right = newNode(13); ` ` ` ` ` `cout << SumKLargestUsingReverseMorrisTraversal(root, 3); ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

**Output:**

32

**Time Complexity:** O(N)

**Space complexity: O(1) **

## Recommended Posts:

- Find maximum in a stack in O(1) time and O(1) extra space
- Print BST keys in given Range | O(1) Space
- Counting Triangles in a Rectangular space using BIT
- Maximize the sum of X+Y elements by picking X and Y elements from 1st and 2nd array
- Find the closest element in Binary Search Tree | Space Efficient Method
- Largest Rectangular Area in a Histogram | Set 1
- Range query for Largest Sum Contiguous Subarray
- Sort elements by frequency | Set 5 (using Java Map)
- Count elements which divide all numbers in range L-R
- Count number of smallest elements in given range
- Array range queries for elements with frequency same as value
- Queries for number of distinct elements in a subarray
- Merge Sort Tree (Smaller or equal elements in given row range)
- Number of elements greater than K in the range L to R using Fenwick Tree (Offline queries)
- Number of elements less than or equal to a given number in a given subarray | Set 2 (Including Updates)

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.