Find k-th smallest element in BST (Order Statistics in BST) - GeeksforGeeks

02 May, 2022
Given the root of a binary search tree and K as input, find Kth 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++
C
Java
Python3
C#
Javascript
// A simple inorder traversal based C++ program to find k-th// smallest element in a BST.#include <iostream> using namespace std; // A BST nodestruct Node {    int data;    Node *left, *right;    Node(int x)    {        data = x;        left = right = NULL;    }}; // Recursive function to insert an key into BSTNode* 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 smallest element in BST// Here count denotes the number of nodes processed so farint count = 0;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 print k'th smallest element in BSTvoid printKthSmallest(Node* root, int k){    // maintain index to count number of nodes processed so far     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;} // main functionint 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;} // This code is contributed by Aditya Kumar (adityakumar129)
// A simple inorder traversal based C++ program to find k-th// smallest element in a BST.#include <stdio.h>#include <stdlib.h> // A BST nodetypedef struct Node {    int data;    struct Node *left, *right;} Node; struct Node* new_node(int x){    struct Node* p = malloc(sizeof(struct Node));    p->data = x;    p->left = NULL;    p->right = NULL;    return p;} // Recursive function to insert an key into BSTNode* 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 smallest element in BST// Here count denotes the number of nodes processed so farint count = 0;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 print k'th smallest element in BSTvoid printKthSmallest(Node* root, int k){    // maintain index to count number of nodes processed so far    Node* res = kthSmallest(root, k);    if (res == NULL)        printf("There are less than k nodes in the BST");    else        printf("K-th Smallest Element is %d", res->data);} // main functionint main(){    Node* root = NULL;    int keys[] = { 20, 8, 22, 4, 12, 10, 14 };    int keys_size = sizeof(keys) / sizeof(keys[0]);     for (int i = 0; i < keys_size; i++)        root = insert(root, keys[i]);     int k = 3;    printKthSmallest(root, k);    return 0;} // This code is contributed by Aditya Kumar (adityakumar129)
// A simple inorder traversal based Java program// to find k-th smallest element in a BST. import java.io.*;// A BST nodeclass 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)    {        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);    }} // This code is contributed by Aditya Kumar (adityakumar129)
# A simple inorder traversal based Python3# program to find k-th smallest element# in a BST. # A BST nodeclass Node:         def __init__(self, key):                 self.data = key        self.left = None        self.right = None # Recursive function to insert an key into BSTdef insert(root, x):         if (root == None):        return Node(x)    if (x < root.data):        root.left = insert(root.left, x)    elif (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 fardef kthSmallest(root):         global k         # Base case    if (root == None):        return None     # Search in left subtree    left = kthSmallest(root.left)     # If k'th smallest is found in    # left subtree, return it    if (left != None):        return left             # If current element is k'th    # smallest, return it    k -= 1    if (k == 0):        return root     # Else search in right subtree    return kthSmallest(root.right) # Function to find k'th largest element in BSTdef printKthSmallest(root):         # Maintain index to count number    # of nodes processed so far    count = 0    res = kthSmallest(root)         if (res == None):        print("There are less than k nodes in the BST")    else:        print("K-th Smallest Element is ", res.data) # Driver codeif __name__ == '__main__':         root = None    keys = [ 20, 8, 22, 4, 12, 10, 14 ]     for x in keys:        root = insert(root, x)     k = 3         printKthSmallest(root) # This code is contributed by mohit kumar 29
// A simple inorder traversal// based C# program to find// k-th smallest element in a BST.using System; // A BST nodeclass Node{ public int data;public Node left, right;public Node(int x){  data = x;  left = right = null;}} class GFG{    static int count = 0; // Recursive function to // insert an key into BSTpublic 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 farpublic 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 BSTpublic 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)    Console.WriteLine("There are less " +                      "than k nodes in the BST");  else    Console.WriteLine("K-th Smallest" +                      " Element is " + res.data);} // Driver codepublic static void Main(String[] args){   Node root = null;  int []keys = {20, 8, 22, 4,                12, 10, 14};     foreach (int x in keys)    root = insert(root, x);   int k = 3;  printKthSmallest(root, k);}} // This code is contributed by gauravrajput1
<script>// A simple inorder traversal based Javascript program// to find k-th smallest element in a BST.         // A BST node    class Node    {        constructor(x) {            this.data = x;            this.left = null;            this.right = null;          }    }         let count = 0;         // Recursive function to insert an key into BST    function insert(root,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    function kthSmallest(root,k)    {        // base case        if (root == null)            return null;               // search in left subtree        let 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    function printKthSmallest(root,k)    {        // maintain an index to count number of        // nodes processed so far        count = 0;                  let res = kthSmallest(root, k);        if (res == null)            document.write("There are less "                        + "than k nodes in the BST");        else            document.write("K-th Smallest"                    + " Element is " + res.data);    }         let root=null;    let key=[20, 8, 22, 4, 12, 10, 14 ];    for(let i=0;i<key.length;i++)    {        root = insert(root, key[i]);    }         let k = 3;    printKthSmallest(root, k);                  // This code is contributed by unknown2108</script>
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++
C
Java
Python3
C#
Javascript
// A simple inorder traversal based C++ program to find k-th// smallest element in a BST.#include <iostream>using namespace std; // A BST nodestruct 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 BSTNode* 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 smallest element in BST// Here count denotes the number of nodes processed so farNode* 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 functionint 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;} // This code is contributed by Aditya Kumar (adityakumar129)
// A simple inorder traversal based C++ program to find k-th// smallest element in a BST.#include <stdio.h>#include <stdlib.h> // A BST nodetypedef struct Node {    int data;    struct Node *left, *right;    int lCount;} Node; Node* new_node(int x){    Node* newNode = malloc(sizeof(Node));    newNode->data = x;    newNode->left = NULL;    newNode->right = NULL;    return newNode;} // Recursive function to insert an key into BSTNode* 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 smallest element in BST// Here count denotes the number of nodes processed so farNode* 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 functionint main(){    Node* root = NULL;    int keys[] = { 20, 8, 22, 4, 12, 10, 14 };    int keys_size = sizeof(keys) / sizeof(keys[0]);     for (int i = 0; i < keys_size; i++)        root = insert(root, keys[i]);    int k = 4;    Node* res = kthSmallest(root, k);    if (res == NULL)        printf("There are less than k nodes in the BST");    else        printf("K-th Smallest Element is %d", res->data);    return 0;} // This code is contributed by Aditya Kumar (adityakumar129)
// A simple inorder traversal based Java program// to find k-th smallest element in a BST.import java.io.*;import java.util.*; // A BST nodeclass 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);    }} // This code is contributed by Aditya Kumar (adityakumar129)
# A simple inorder traversal based Python3# program to find k-th smallest element in a BST. # A BST nodeclass newNode:         def __init__(self, x):                 self.data = x        self.left = None        self.right = None        self.lCount = 0 # Recursive function to insert# an key into BSTdef insert(root, x):         if (root == None):        return newNode(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 += 1     elif (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 fardef kthSmallest(root, k):         # Base case    if (root == None):        return None             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) # Driver codeif __name__ == '__main__':         root = None    keys = [ 20, 8, 22, 4, 12, 10, 14 ]     for x in keys:        root = insert(root, x)     k = 4    res = kthSmallest(root, k)         if (res == None):        print("There are less than k nodes in the BST")    else:        print("K-th Smallest Element is", res.data)         # This code is contributed by bgangwar59
// A simple inorder traversal based C# program// to find k-th smallest element in a BST.using System; // A BST nodepublic class Node{    public int data;    public Node left, right;    public int lCount;         public Node(int x)    {        data = x;        left = right = null;        lCount = 0;    }} class GFG{     // Recursive function to insert an key into BSTpublic 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 farpublic 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);} // Driver Codepublic static void Main(String[] args){    Node root = null;    int[] keys = { 20, 8, 22, 4, 12, 10, 14 };     foreach(int x in keys)        root = insert(root, x);     int k = 4;    Node res = kthSmallest(root, k);         if (res == null)        Console.WriteLine("There are less " +                          "than k nodes in the BST");    else        Console.WriteLine("K-th Smallest" +                          " Element is " + res.data);}} // This code is contributed by aashish1995
<script> // A simple inorder traversal based// Javascript program to find k-th// smallest element in a BST. // A BST nodeclass Node{    constructor(x)    {        this.data = x;        this.left = null;        this.right = null;        this.lCount = 0;    }} // Recursive function to insert an key into BSTfunction insert(root, 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 farfunction kthSmallest(root, k){         // Base case    if (root == null)        return null;     let 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);} // Driver codelet root = null;let keys = [ 20, 8, 22, 4, 12, 10, 14 ]; for(let x = 0; x < keys.length; x++)    root = insert(root, keys[x]); let k = 4;let res = kthSmallest(root, k);  if (res == null)    document.write("There are less than k " +                   "nodes in the BST" + "</br>");else    document.write("K-th Smallest" +                   " Element is " + res.data);                    // This code is contributed by divyeshrabadiya07 </script>
K-th Smallest Element is 12
 
Time complexity: O(h) where h is the height of the tree.
Dheerain Jain
Akanksha_Rai
jaydipdushi
RICHIK BHATTACHARJEE
kushalvm
GauravRajput1
bgangwar59
mohit kumar 29
aashish1995
unknown2108
divyeshrabadiya07
simmytarika5
debayanbiswas31
adityakumar129
Accolite
Amazon
Google
Order-Statistics
Binary Search Tree
Accolite
Amazon
Google
Binary Search Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Sorted Array to Balanced BST
Optimal Binary Search Tree | DP-24
Red-Black Tree | Set 2 (Insert)
Inorder Successor in Binary Search Tree
Find the node with minimum value in a Binary Search Tree
Advantages of BST over Hash Table
Overview of Data Structures | Set 2 (Binary Tree, BST, Heap and Hash)
Difference between Binary Tree and Binary Search Tree
Binary Tree to Binary Search Tree Conversion
Inorder predecessor and successor for a given key in BST