 GeeksforGeeks App
Open App Browser
Continue

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

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++

 `// A simple inorder traversal based C++ program to find k-th``// smallest element in a BST.``#include ` `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 smallest element in BST``// Here count denotes the number of nodes processed so far``int` `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 BST``void` `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 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;``}` `// This code is contributed by Aditya Kumar (adityakumar129)`

## C

 `// A simple inorder traversal based C++ program to find k-th``// smallest element in a BST.``#include ``#include ` `// A BST node``typedef` `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 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 smallest element in BST``// Here count denotes the number of nodes processed so far``int` `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 BST``void` `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 function``int` `main()``{``    ``Node* root = NULL;``    ``int` `keys[] = { 20, 8, 22, 4, 12, 10, 14 };``    ``int` `keys_size = ``sizeof``(keys) / ``sizeof``(keys);` `    ``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)`

## Java

 `// A simple inorder traversal based Java 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 smallest 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 smallest 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)`

## Python3

 `# A simple inorder traversal based Python3``# program to find k-th smallest element``# in a BST.` `# A BST node`  `class` `Node:` `    ``def` `__init__(``self``, key):` `        ``self``.data ``=` `key``        ``self``.left ``=` `None``        ``self``.right ``=` `None` `# Recursive function to insert an key into BST`  `def` `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 far`  `def` `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 BST`  `def` `printKthSmallest(root):` `    ``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 code``if` `__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`

## C#

 `// A simple inorder traversal``// based C# program to find``// k-th smallest element in a BST.``using` `System;` `// A BST node``class` `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 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``)``    ``Console.WriteLine(``"There are less "` `+``                      ``"than k nodes in the BST"``);``  ``else``    ``Console.WriteLine(``"K-th Smallest"` `+``                      ``" Element is "` `+ res.data);``}` `// Driver code``public` `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`

## Javascript

 ``

Output

`K-th Smallest Element is 10`

Time complexity: O(h) where h is the height of the tree.
Auxiliary Space: O(h)

We can optimize space using Morris Traversal. Please refer K’th smallest element in BST using O(1) Extra Space for details.

Method 2: Using Any Tree Traversal (pre-in-post) than return kth smallest easily.

Approach:

Here we use pre order traversal than sort it and return the kth smallest element.

``` Algorithm:
Here we have tree we will take preorder of it as :
``` preorder will : 20 8 4 12 10 14 22

```  And store it in array/vector.
After taking preorder we will sort it and than return k-1 element from the array.```

## C++

 `// A simple inorder traversal based C++ program to find k-th``// smallest element in a BST.``#include ``#include ``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;``}``//preorder function.``void` `preorder(Node* root,vector<``int``>&v){``    ``if``(root==NULL)``return``;``    ``v.push_back(root->data);``    ``preorder(root->left,v);``    ``preorder(root->right,v);``}``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;``    ``vector<``int``>v;``    ``preorder(root,v);``    ``//for(auto it:v)cout<

## Java

 `import` `java.util.*;` `class` `Node {``    ``int` `data;``    ``Node left, right;``    ``int` `lCount;``    ``Node(``int` `x) {``        ``data = x;``        ``left = right = ``null``;``        ``lCount = ``0``;``    ``}``}` `public` `class` `KthSmallestElementBST {``    ``// Recursive function to insert a key into BST``    ``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;``    ``}` `    ``// Preorder traversal of BST``    ``static` `void` `preorder(Node root, List v) {``        ``if` `(root == ``null``) ``return``;``        ``v.add(root.data);``        ``preorder(root.left, v);``        ``preorder(root.right, v);``    ``}` `    ``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``;``        ``List v = ``new` `ArrayList();``        ``preorder(root, v);` `        ``// Sorting the given vector``        ``Collections.sort(v);` `        ``// Finding kth smallest element``        ``System.out.println(v.get(k-``1``));``    ``}``}`

## Python3

 `# A BST node``class` `Node:``    ``def` `__init__(``self``, x):``        ``self``.data ``=` `x``        ``self``.left ``=` `None``        ``self``.right ``=` `None``        ``self``.lCount ``=` `0` `# Recursive function to insert a key into BST``def` `insert(root, x):``    ``if` `root ``is` `None``:``        ``return` `Node(x)` `    ``# If a node is inserted in the 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` `# Preorder traversal function``def` `preorder(root, v):``    ``if` `root ``is` `None``:``        ``return``    ``v.append(root.data)``    ``preorder(root.left, v)``    ``preorder(root.right, v)` `# Main function``if` `__name__ ``=``=` `'__main__'``:``    ``root ``=` `None``    ``keys ``=` `[``20``, ``8``, ``22``, ``4``, ``12``, ``10``, ``14``]``    ``for` `x ``in` `keys:``        ``root ``=` `insert(root, x)``    ``k ``=` `4``    ``v ``=` `[]``    ``preorder(root, v)` `    ``# Sorting the given list``    ``v.sort()` `    ``# Return the kth smallest element``    ``print``(v[k``-``1``])`

## C#

 `using` `System;``using` `System.Collections.Generic;` `class` `Program``{``    ``// A BST node``    ``class` `Node``    ``{``        ``public` `int` `data;``        ``public` `Node left, right;``        ``public` `int` `lCount;``        ``public` `Node(``int` `x)``        ``{``            ``data = x;``            ``left = right = ``null``;``            ``lCount = 0;``        ``}``    ``}` `    ``// Recursive function to insert an key into BST``    ``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;``    ``}` `    ``// Inorder traversal to get sorted order``    ``static` `void` `inorder(Node root, List<``int``> v)``    ``{``        ``if` `(root == ``null``) ``return``;``        ``inorder(root.left, v);``        ``v.Add(root.data);``        ``inorder(root.right, v);``    ``}` `    ``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;``        ``List<``int``> v = ``new` `List<``int``>();``        ``inorder(root, v);` `        ``// k-th smallest element is at index k-1 in the sorted array``        ``Console.WriteLine(v[k - 1]);``    ``}``}`

## Javascript

 `class Node {``  ``constructor(x) {``    ``this``.data = x;``    ``this``.left = ``null``;``    ``this``.right = ``null``;``    ``this``.lCount = 0;``  ``}``}` `function` `insert(root, x) {``  ``if` `(root === ``null``) {``    ``return` `new` `Node(x);``  ``}` `  ``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` `preorder(root, v) {``  ``if` `(root === ``null``) {``    ``return``;``  ``}` `  ``v.push(root.data);``  ``preorder(root.left, v);``  ``preorder(root.right, v);``}` `let root = ``null``;``const keys = [20, 8, 22, 4, 12, 10, 14];` `for` `(const x of keys) {``  ``root = insert(root, x);``}` `const k = 4;``const v = [];` `preorder(root, v);` `v.sort((a, b) => a - b);` `console.log(v[k - 1]);`

Output

`12`

Complexity Analysis:

Time Complexity: O(nlogn) i.e O(n) time for preorder and nlogn time for sorting.
Auxiliary Space: O(n) i.e for vector/array storage.

Method 3: 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 ``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 smallest 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;``}` `// This code is contributed by Aditya Kumar (adityakumar129)`

## C

 `// A simple inorder traversal based C++ program to find k-th``// smallest element in a BST.``#include ``#include ` `// A BST node``typedef` `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 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 smallest 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 };``    ``int` `keys_size = ``sizeof``(keys) / ``sizeof``(keys);` `    ``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)`

## Java

 `// A simple inorder traversal based Java 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);``    ``}``}` `// This code is contributed by Aditya Kumar (adityakumar129)`

## Python3

 `# A simple inorder traversal based Python3``# program to find k-th smallest element in a BST.` `# A BST node``class` `newNode:``    ` `    ``def` `__init__(``self``, x):``        ` `        ``self``.data ``=` `x``        ``self``.left ``=` `None``        ``self``.right ``=` `None``        ``self``.lCount ``=` `0` `# Recursive function to insert``# an key into BST``def` `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 far``def` `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 code``if` `__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`

## C#

 `// A simple inorder traversal based C# program``// to find k-th smallest element in a BST.``using` `System;` `// A BST node``public` `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 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);``}` `// Driver Code``public` `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`

## Javascript

 ``

Output

`K-th Smallest Element is 12`

Time complexity: O(h) where h is the height of the tree.
Auxiliary Space: O(h)

Method 4: Iterative approach using Stack: The basic idea behind the Iterative Approach using Stack to find the kth smallest element in a Binary Search Tree (BST) is to traverse the tree in an inorder fashion using a stack until we find the kth smallest element. Follow the steps to implement the above idea:

1. Create an empty stack and set the current node to the root of the BST.
2. Push all the left subtree nodes of the current node onto the stack until the current node is NULL.
3. Pop the top node from the stack and check if it is the k-th element. If it is, return its value.
4. Decrement the value of k by 1.
5. Set the current node to the right child of the popped node.
6. Go to step 2 if the stack is not empty or k is not equal to 0.

Below is the implementation of the above approach:

## C++

 `// C++ code to implement the iterative approach``#include ``#include ``using` `namespace` `std;` `// Definition of a BST node``struct` `Node {``    ``int` `data;``    ``Node *left, *right;``};` `// Function to create a new BST node``Node* newNode(``int` `key)``{``    ``Node* node = ``new` `Node;``    ``node->data = key;``    ``node->left = node->right = NULL;``    ``return` `node;``}` `// Function to insert a new node in BST``Node* insert(Node* root, ``int` `key)``{``    ``// If the tree is empty, return a new node``    ``if` `(root == NULL)``        ``return` `newNode(key);` `    ``// Otherwise, recur down the tree``    ``if` `(key < root->data)``        ``root->left = insert(root->left, key);``    ``else` `if` `(key > root->data)``        ``root->right = insert(root->right, key);` `    ``// Return the (unchanged) node pointer``    ``return` `root;``}` `// Function to find the k-th smallest``// element in BST``int` `kthSmallest(Node* root, ``int` `k)``{``    ``// Create an empty stack``    ``stack s;` `    ``// Loop until stack is empty or``    ``// k becomes zero``    ``while` `(root != NULL || !s.empty()) {` `        ``// Push all the left subtree``        ``// nodes onto the stack``        ``while` `(root != NULL) {``            ``s.push(root);``            ``root = root->left;``        ``}` `        ``// Pop the top node from the``        ``// stack and check if it is``        ``// the k-th element``        ``root = s.top();``        ``s.pop();` `        ``if` `(--k == 0)``            ``return` `root->data;` `        ``// Set root to the right child``        ``// and continue with the traversal``        ``root = root->right;``    ``}` `    ``// If k is greater than the number``    ``// of nodes in BST, return -1``    ``return` `-1;``}` `// Driver Code``int` `main()``{``    ``Node* root = NULL;``    ``int` `keys[] = { 20, 8, 22, 4, 12, 10, 14 };` `    ``// Insert all the keys into BST``    ``for` `(``int` `x : keys)``        ``root = insert(root, x);` `    ``int` `k = 4;` `    ``// Find the k-th smallest element in BST``    ``int` `kth_smallest = kthSmallest(root, k);``    ``if` `(kth_smallest != -1)``        ``cout << ``"K-th smallest element in BST is: "``             ``<< kth_smallest << endl;``    ``else``        ``cout << ``"Invalid input"` `<< endl;` `    ``return` `0;``}`

## Python3

 `# Python code to implement the iterative approach` `# Definition of a BST node`  `class` `Node:``    ``def` `__init__(``self``, key):``        ``self``.data ``=` `key``        ``self``.left ``=` `None``        ``self``.right ``=` `None` `# Function to insert a new node in BST`  `def` `insert(root, key):``    ``# If the tree is empty, return a new node``    ``if` `root ``is` `None``:``        ``return` `Node(key)` `    ``# Otherwise, recur down the tree``    ``if` `key < root.data:``        ``root.left ``=` `insert(root.left, key)``    ``elif` `key > root.data:``        ``root.right ``=` `insert(root.right, key)` `    ``# Return the (unchanged) node pointer``    ``return` `root` `# Function to find the k-th smallest``# element in BST`  `def` `kthSmallest(root, k):``    ``# Create an empty stack``    ``stack ``=` `[]` `    ``# Loop until stack is empty or``    ``# k becomes zero``    ``while` `root ``is` `not` `None` `or` `len``(stack) > ``0``:` `        ``# Push all the left subtree``        ``# nodes onto the stack``        ``while` `root ``is` `not` `None``:``            ``stack.append(root)``            ``root ``=` `root.left` `        ``# Pop the top node from the``        ``# stack and check if it is``        ``# the k-th element``        ``root ``=` `stack.pop()``        ``k ``-``=` `1` `        ``if` `k ``=``=` `0``:``            ``return` `root.data` `        ``# Set root to the right child``        ``# and continue with the traversal``        ``root ``=` `root.right` `    ``# If k is greater than the number``    ``# of nodes in BST, return -1``    ``return` `-``1`  `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``root ``=` `None``    ``keys ``=` `[``20``, ``8``, ``22``, ``4``, ``12``, ``10``, ``14``]` `    ``# Insert all the keys into BST``    ``for` `x ``in` `keys:``        ``root ``=` `insert(root, x)` `    ``k ``=` `4` `    ``# Find the k-th smallest element in BST``    ``kth_smallest ``=` `kthSmallest(root, k)``    ``if` `kth_smallest !``=` `-``1``:``        ``print``(``"K-th smallest element in BST is:"``, kth_smallest)``    ``else``:``        ``print``(``"Invalid input"``)`

Output

`K-th smallest element in BST is: 12`

Time Complexity: O(h+ k), The time complexity of the Iterative Approach using Stack to find the kth smallest element in a BST is O(h + k), where h is the height of the BST and k is the value of k.

Auxiliary Space: O(h+k), The space complexity of the code is O(h + k), where h is the height of the BST and k is the maximum size of the stack.

My Personal Notes arrow_drop_up