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++
#include <iostream>
using namespace std;
struct Node {
int data;
Node *left, *right;
Node( int x)
{
data = x;
left = right = NULL;
}
};
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;
}
int count = 0;
Node* kthSmallest(Node* root, int & k)
{
if (root == NULL)
return NULL;
Node* left = kthSmallest(root->left, k);
if (left != NULL)
return left;
count++;
if (count == k)
return root;
return kthSmallest(root->right, k);
}
void printKthSmallest(Node* root, int k)
{
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;
}
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;
}
|
C
#include <stdio.h>
#include <stdlib.h>
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;
}
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;
}
int count = 0;
Node* kthSmallest(Node* root, int k)
{
if (root == NULL)
return NULL;
Node* left = kthSmallest(root->left, k);
if (left != NULL)
return left;
count++;
if (count == k)
return root;
return kthSmallest(root->right, k);
}
void printKthSmallest(Node* root, int k)
{
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);
}
int 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;
}
|
Java
import java.io.*;
class Node {
int data;
Node left, right;
Node( int x)
{
data = x;
left = right = null ;
}
}
class GFG {
static int count = 0 ;
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;
}
public static Node kthSmallest(Node root, int k)
{
if (root == null )
return null ;
Node left = kthSmallest(root.left, k);
if (left != null )
return left;
count++;
if (count == k)
return root;
return kthSmallest(root.right, k);
}
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);
}
}
|
Python3
class Node:
def __init__( self , key):
self .data = key
self .left = None
self .right = None
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
def kthSmallest(root):
global k
if (root = = None ):
return None
left = kthSmallest(root.left)
if (left ! = None ):
return left
k - = 1
if (k = = 0 ):
return root
return kthSmallest(root.right)
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)
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)
|
C#
using System;
class Node{
public int data;
public Node left, right;
public Node( int x)
{
data = x;
left = right = null ;
}
}
class GFG{
static int count = 0;
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;
}
public static Node kthSmallest(Node root,
int k)
{
if (root == null )
return null ;
Node left = kthSmallest(root.left, k);
if (left != null )
return left;
count++;
if (count == k)
return root;
return kthSmallest(root.right, k);
}
public static void printKthSmallest(Node root,
int k)
{
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);
}
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);
}
}
|
Javascript
<script>
class Node
{
constructor(x) {
this .data = x;
this .left = null ;
this .right = null ;
}
}
let count = 0;
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 kthSmallest(root,k)
{
if (root == null )
return null ;
let left = kthSmallest(root.left, k);
if (left != null )
return left;
count++;
if (count == k)
return root;
return kthSmallest(root.right, k);
}
function printKthSmallest(root,k)
{
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);
</script>
|
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: 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++
#include <iostream>
using namespace std;
struct Node {
int data;
Node *left, *right;
int lCount;
Node( int x)
{
data = x;
left = right = NULL;
lCount = 0;
}
};
Node* insert(Node* root, int 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;
}
Node* kthSmallest(Node* root, int k)
{
if (root == NULL)
return NULL;
int count = root->lCount + 1;
if (count == k)
return root;
if (count > k)
return kthSmallest(root->left, k);
return kthSmallest(root->right, k - count);
}
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;
}
|
C
#include <stdio.h>
#include <stdlib.h>
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;
}
Node* insert(Node* root, int 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;
}
Node* kthSmallest(Node* root, int k)
{
if (root == NULL)
return NULL;
int count = root->lCount + 1;
if (count == k)
return root;
if (count > k)
return kthSmallest(root->left, k);
return kthSmallest(root->right, k - count);
}
int 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;
}
|
Java
import java.io.*;
import java.util.*;
class Node {
int data;
Node left, right;
int lCount;
Node( int x)
{
data = x;
left = right = null ;
lCount = 0 ;
}
}
class Gfg {
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);
root.lCount++;
}
else if (x > root.data)
root.right = insert(root.right, x);
return root;
}
public static Node kthSmallest(Node root, int k)
{
if (root == null )
return null ;
int count = root.lCount + 1 ;
if (count == k)
return root;
if (count > k)
return kthSmallest(root.left, k);
return kthSmallest(root.right, k - count);
}
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);
}
}
|
Python3
class newNode:
def __init__( self , x):
self .data = x
self .left = None
self .right = None
self .lCount = 0
def insert(root, x):
if (root = = None ):
return newNode(x)
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
def kthSmallest(root, k):
if (root = = None ):
return None
count = root.lCount + 1
if (count = = k):
return root
if (count > k):
return kthSmallest(root.left, k)
return kthSmallest(root.right, k - count)
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)
|
C#
using System;
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{
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);
root.lCount++;
}
else if (x > root.data)
root.right = insert(root.right, x);
return root;
}
public static Node kthSmallest(Node root, int k)
{
if (root == null )
return null ;
int count = root.lCount + 1;
if (count == k)
return root;
if (count > k)
return kthSmallest(root.left, k);
return kthSmallest(root.right, k - count);
}
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);
}
}
|
Javascript
<script>
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 kthSmallest(root, k)
{
if (root == null )
return null ;
let count = root.lCount + 1;
if (count == k)
return root;
if (count > k)
return kthSmallest(root.left, k);
return kthSmallest(root.right, k - count);
}
let 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);
</script>
|
Output: K-th Smallest Element is 12
Time complexity: O(h) where h is the height of the tree.
Auxiliary Space: O(h)
Please Login to comment...