Find k-th smallest element in BST (Order Statistics in BST)
Given the root of a binary search tree and K as input, find K-th smallest element in BST.
For example, in the following BST, if k = 3, then the output should be 10, and if k = 5, then the output should be 14.
Method 1: Using Inorder Traversal (O(n) time and O(h) auxiliary space)
The Inorder Traversal of a BST traverses the nodes in increasing order. So the idea is to traverse the tree in Inorder. While traversing, keep track of the count of the nodes visited. If the count becomes k, print the node.
C++
// A simple inorder traversal based C++ program // to find k-th smallest element in a BST. #include <iostream> using namespace std; // A BST node struct Node { int data; Node *left, *right; Node(int x) { data = x; left = right = NULL; } }; // Recursive function to insert an key into BST Node* insert(Node* root, int x) { if (root == NULL) return new Node(x); if (x < root->data) root->left = insert(root->left, x); else if (x > root->data) root->right = insert(root->right, x); return root; } // Function to find k'th largest element in BST // Here count denotes the number of nodes processed so far Node* kthSmallest(Node* root, int& count, int k) { // base case if (root == NULL) return NULL; // search in left subtree Node* left = kthSmallest(root->left, count, k); // if k'th smallest is found in left subtree, return it if (left != NULL) return left; // if current element is k'th smallest, return it count++; if (count == k) return root; // else search in right subtree return kthSmallest(root->right, count, k); } // Function to find k'th largest element in BST void printKthSmallest(Node* root, int k) { // maintain index to count number of nodes processed so far int count = 0; Node* res = kthSmallest(root, count, k); if (res == NULL) cout << "There are less than k nodes in the BST"; else cout << "K-th Smallest Element is " << res->data; } // main function int main() { Node* root = NULL; int keys[] = { 20, 8, 22, 4, 12, 10, 14 }; for (int x : keys) root = insert(root, x); int k = 3; printKthSmallest(root, k); return 0; } |
chevron_right
filter_none
Java
// A simple inorder traversal based C++ program // to find k-th smallest element in a BST. import java.io.*; // A BST node class Node { int data; Node left, right; Node(int x) { data = x; left = right = null; } } class GFG { static int count = 0; // Recursive function to insert an key into BST public static Node insert(Node root, int x) { if (root == null) return new Node(x); if (x < root.data) root.left = insert(root.left, x); else if (x > root.data) root.right = insert(root.right, x); return root; } // Function to find k'th largest element in BST // Here count denotes the number // of nodes processed so far public static Node kthSmallest(Node root, int k) { // base case if (root == null) return null; // search in left subtree Node left = kthSmallest(root.left, k); // if k'th smallest is found in left subtree, return it if (left != null) return left; // if current element is k'th smallest, return it count++; if (count == k) return root; // else search in right subtree return kthSmallest(root.right, k); } // Function to find k'th largest element in BST public static void printKthSmallest(Node root, int k) { // maintain an index to count number of // nodes processed so far count = 0; Node res = kthSmallest(root, k); if (res == null) System.out.println("There are less " + "than k nodes in the BST"); else System.out.println("K-th Smallest" + " Element is " + res.data); } public static void main (String[] args) { Node root = null; int keys[] = { 20, 8, 22, 4, 12, 10, 14 }; for (int x : keys) root = insert(root, x); int k = 3; printKthSmallest(root, k); } } |
chevron_right
filter_none
Output:
K-th Smallest Element is 10
We can optimize space using Morris Traversal. Please refer K’th smallest element in BST using O(1) Extra Space for details.
Method 2: Augmented Tree Data Structure (O(h) Time Complexity and O(h) auxiliary space)
The idea is to maintain the rank of each node. We can keep track of elements in the left subtree of every node while building the tree. Since we need the K-th smallest element, we can maintain the number of elements of the left subtree in every node.
Assume that the root is having ‘lCount’ nodes in its left subtree. If K = lCount + 1, root is K-th node. If K < lCount + 1, we will continue our search (recursion) for the Kth smallest element in the left subtree of root. If K > lCount + 1, we continue our search in the right subtree for the (K – lCount – 1)-th smallest element. Note that we need the count of elements in the left subtree only.
C++
// A simple inorder traversal based C++ program // to find k-th smallest element in a BST. #include <iostream> using namespace std; // A BST node struct Node { int data; Node *left, *right; int lCount; Node(int x) { data = x; left = right = NULL; lCount = 0; } }; // Recursive function to insert an key into BST Node* insert(Node* root, int x) { if (root == NULL) return new Node(x); // If a node is inserted in left subtree, then // lCount of this node is increased. For simplicity, // we are assuming that all keys (tried to be // inserted) are distinct. if (x < root->data) { root->left = insert(root->left, x); root->lCount++; } else if (x > root->data) root->right = insert(root->right, x); return root; } // Function to find k'th largest element in BST // Here count denotes the number of nodes processed so far Node* kthSmallest(Node* root, int k) { // base case if (root == NULL) return NULL; int count = root->lCount + 1; if (count == k) return root; if (count > k) return kthSmallest(root->left, k); // else search in right subtree return kthSmallest(root->right, k - count); } // main function int main() { Node* root = NULL; int keys[] = { 20, 8, 22, 4, 12, 10, 14 }; for (int x : keys) root = insert(root, x); int k = 4; Node* res = kthSmallest(root, k); if (res == NULL) cout << "There are less than k nodes in the BST"; else cout << "K-th Smallest Element is " << res->data; return 0; } |
chevron_right
filter_none
Java
// A simple inorder traversal based C++ program // to find k-th smallest element in a BST. import java.io.*; import java.util.*; // A BST node class Node { int data; Node left, right; int lCount; Node(int x) { data = x; left = right = null; lCount = 0; } } class Gfg { // Recursive function to insert an key into BST public static Node insert(Node root, int x) { if (root == null) return new Node(x); // If a node is inserted in left subtree, then // lCount of this node is increased. For simplicity, // we are assuming that all keys (tried to be // inserted) are distinct. if (x < root.data) { root.left = insert(root.left, x); root.lCount++; } else if (x > root.data) root.right = insert(root.right, x); return root; } // Function to find k'th largest element in BST // Here count denotes the number of // nodes processed so far public static Node kthSmallest(Node root, int k) { // base case if (root == null) return null; int count = root.lCount + 1; if (count == k) return root; if (count > k) return kthSmallest(root.left, k); // else search in right subtree return kthSmallest(root.right, k - count); } // main function public static void main(String args[]) { Node root = null; int keys[] = { 20, 8, 22, 4, 12, 10, 14 }; for (int x : keys) root = insert(root, x); int k = 4; Node res = kthSmallest(root, k); if (res == null) System.out.println("There are less " + "than k nodes in the BST"); else System.out.println("K-th Smallest" + " Element is " + res.data); } } |
chevron_right
filter_none
Output:
K-th Smallest Element is 12
Time complexity: O(h) where h is height of tree.
Thanks to Venki for providing post. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
GeeksforGeeks has prepared a complete interview preparation course with premium videos, theory, practice problems, TA support and many more features. Please refer Placement 100 for details
Recommended Posts:
- Find k-th smallest element in given n ranges
- Python heapq to find K'th smallest element in a 2D array
- k smallest elements in same order using O(1) extra space
- Find the smallest and second smallest elements in an array
- K’th Smallest/Largest Element using STL
- K'th smallest element in BST using O(1) Extra Space
- Smallest Greater Element on Right Side
- K'th Smallest/Largest Element in Unsorted Array | Set 1
- K'th Smallest/Largest Element in Unsorted Array | Set 2 (Expected Linear Time)
- K'th Smallest/Largest Element in Unsorted Array | Set 2 (Expected Linear Time)
- K'th Smallest/Largest Element in Unsorted Array | Set 3 (Worst Case Linear Time)
- Kth smallest element in a row-wise and column-wise sorted 2D array | Set 1
- Given a number, find the next smallest palindrome
- Find m-th smallest value in k sorted arrays
- Find k pairs with smallest sums in two arrays
