Kth Smallest element in a Perfect Binary Search Tree

• Difficulty Level : Medium
• Last Updated : 30 Jun, 2021

Given a Perfect BST with N nodes and an integer K, the task is to find the Kth smallest element is present in the tree.

Example:

Input:
K = 3, N = 15
50
/     \
30        70
/  \      /  \
20   40    60    80
/\   /\    /\    / \
14 25 35 45 55 65 75  85
Output: 25

Explanation:
The 3rd smallest element
in the given BST is 25

Input:
K = 9, N = 15
50
/       \
30        70
/  \      /  \
20   40    60    80
/\   /\    /\    / \
14 25 35 45 55 65 75  85
Output: 55

Explanation:
The 9th smallest element
in the given BST is 55

Naive Approach: Do the Inorder traversal in a perfect BST, such as morris traversal or recursive solution, which visits every node and returns the kth visit key. It takes O(N) time complexity to complete the task.

Efficient Approach:
Since the given BST is perfect and the number of nodes of the entire tree is already known, the computational complexity to solve the problem can be reduced to log(N). Follow the steps given below to solve the problem:

• in a perfect BST tree(N), |N| will always be odd in a perfect binary tree, the location of the median in any perfect BST is floor(|N|/2) + 1.
• Calculate the number of nodes in every sub-tree by dividing the total nodes as floor(|N| / 2).
• The left sub-tree of the Perfect BST will always contain the Kth smallest element if:
• K < location(median(N))=M this is because Mth smallest element will always be larger than the Kth smallest element and every element in the right sub-tree will be larger than the Mth smallest element
• The right sub-tree of Perfect BST will always contain a Rth smallest element if:
• K > location(median(N))=M, in this case, K – location(median(N))=R is the Rth smallest element in the right subtree. This is because Rth smallest element in the right sub-tree is larger than Mth smallest element and every element in the left-sub tree is smaller than Mth smallest element but Rth smallest element is larger than all of them. One may think of R as the new number when at least M smaller possibilities can be ignored. The Rth smallest element is the Kth smallest element when recurring into the right sub-tree (But keep in mind that R != K !).
• If K is location(median(T)), then that node contains the Kth smallest element in perfect BST.

Below is the implementation of the above approach:

C++

 // C++ program to find K-th// smallest element in a// perfect BST#include using namespace std; // A BST nodestruct Node{    int key;    Node *left, *right;}; // A utility function to// create a new BST nodeNode* newNode(int item){    Node* temp = new Node;    temp->key = item;    temp->left = temp->right = NULL;    return temp;} // A utility function to insert a// new node with given key in BSTNode* insert(Node* node, int key){    // If the tree is empty    if (node == NULL)        return newNode(key);     // Recur down the left    // subtree for smaller values    if (key < node->key)        node->left = insert(node->left, key);     // Recur down the right    // subtree for smaller values    else if (key > node->key)        node->right = insert(node->right, key);     // Return the (unchanged) node pointer    return node;} // FUnction to find Kth Smallest// element in a perfect BSTbool KSmallestPerfectBST(Node* root, int k,                         int treeSize,                         int& kth_smallest){    if (root == NULL)        return false;     // Find the median    // (division operation is floored)    int median_loc = (treeSize / 2) + 1;     // If the element is at    // the median    if (k == median_loc)    {        kth_smallest = root->key;        return true;    }     // calculate the number of nodes in the    // right and left sub-trees    // (division operation is floored)    int newTreeSize = treeSize / 2;     // If median is located higher    if (k < median_loc)    {        return KSmallestPerfectBST(            root->left, k,            newTreeSize, kth_smallest);    }     // If median is located lower    int newK = k - median_loc;    return KSmallestPerfectBST(root->right, newK,                               newTreeSize,                               kth_smallest);} // Driver Codeint main(){    /* Let us create following BST               50           /       \          30        70         /  \      /  \       20   40    60    80       /\   /\    /\    / \     14 25 35 45 55 65 75  85       */    Node* root = NULL;    root = insert(root, 50);    insert(root, 30);    insert(root, 20);    insert(root, 40);    insert(root, 70);    insert(root, 60);    insert(root, 80);    insert(root, 14);    insert(root, 25);    insert(root, 35);    insert(root, 45);    insert(root, 55);    insert(root, 65);    insert(root, 75);    insert(root, 85);     int n = 15, k = 5;    int ans = -1;       // Function call    if (KSmallestPerfectBST(root, k, n, ans)) {         cout << ans << " ";    }     return 0;}

Java

 // Java program to find K-th// smallest element in a// perfect BSTimport java.util.*; class GFG{ // A BST node static class Node{    int key;    Node left, right;}; static int kth_smallest; // A utility function to// create a new BST nodepublic static Node newNode(int item){    Node temp = new Node();    temp.key = item;    temp.left = temp.right = null;    return temp;} // A utility function to insert a// new node with given key in BSTstatic Node insert(Node node, int key){         // If the tree is empty    if (node == null)        return newNode(key);     // Recur down the left    // subtree for smaller values    if (key < node.key)        node.left = insert(node.left, key);     // Recur down the right    // subtree for smaller values    else if (key > node.key)        node.right = insert(node.right, key);     // Return the (unchanged) node pointer    return node;} // FUnction to find Kth Smallest// element in a perfect BSTstatic boolean KSmallestPerfectBST(Node root, int k,                                   int treeSize){    if (root == null)        return false;     // Find the median    // (division operation is floored)    int median_loc = (treeSize / 2) + 1;     // If the element is at    // the median    if (k == median_loc)    {        kth_smallest = root.key;        return true;    }     // calculate the number of nodes in the    // right and left sub-trees    // (division operation is floored)    int newTreeSize = treeSize / 2;     // If median is located higher    if (k < median_loc)    {        return KSmallestPerfectBST(            root.left, k,            newTreeSize);    }     // If median is located lower    int newK = k - median_loc;    return KSmallestPerfectBST(root.right, newK,                               newTreeSize);} // Driver Codepublic static void main(String[] args){    /* Let us create following BST               50           /       \          30        70         /  \      /  \       20   40    60    80       /\   /\    /\    / \     14 25 35 45 55 65 75  85       */    Node root = null;    root = insert(root, 50);    insert(root, 30);    insert(root, 20);    insert(root, 40);    insert(root, 70);    insert(root, 60);    insert(root, 80);    insert(root, 14);    insert(root, 25);    insert(root, 35);    insert(root, 45);    insert(root, 55);    insert(root, 65);    insert(root, 75);    insert(root, 85);     int n = 15, k = 5;       // Function call    if (KSmallestPerfectBST(root, k, n))    {        System.out.print(kth_smallest + " ");    }}} // This code is contributed by Amit Katiyar

Python3

 # Python3 program to find K-th# smallest element in a perfect BSTkth_smallest = 0 # A BST nodeclass newNode:         def __init__(self, item):                 self.key = item        self.left = None        self.right = None # A utility function to insert a# new node with given key in BSTdef insert(node, key):         # If the tree is empty    if (node == None):        return newNode(key)     # Recur down the left    # subtree for smaller values    if (key < node.key):        node.left = insert(node.left, key)     # Recur down the right    # subtree for smaller values    elif(key > node.key):        node.right = insert(node.right, key)     # Return the (unchanged) node pointer    return node # FUnction to find Kth Smallest# element in a perfect BSTdef KSmallestPerfectBST(root, k, treeSize):         global kth_smallest         if (root == None):        return False     # Find the median    # (division operation is floored)    median_loc = (treeSize // 2) + 1     # If the element is at    # the median    if (k == median_loc):        kth_smallest = root.key        return True     # Calculate the number of nodes in    # the right and left sub-trees    # (division operation is floored)    newTreeSize = treeSize // 2     # If median is located higher    if (k < median_loc):        return KSmallestPerfectBST(root.left,                                   k, newTreeSize)     # If median is located lower    newK = k - median_loc    return KSmallestPerfectBST(root.right, newK,                               newTreeSize) # Driver Codeif __name__ == '__main__':         ''' Let us create following BST              50           /       \          30        70         /  \      /  \       20   40    60    80       /\   /\    /\    / \     14 25 35 45 55 65 75  85    '''    root = None    root = insert(root, 50)    insert(root, 30)    insert(root, 20)    insert(root, 40)    insert(root, 70)    insert(root, 60)    insert(root, 80)    insert(root, 14)    insert(root, 25)    insert(root, 35)    insert(root, 45)    insert(root, 55)    insert(root, 65)    insert(root, 75)    insert(root, 85)     n = 15    k = 5       # Function call    if (KSmallestPerfectBST(root, k, n)):        print(kth_smallest, end = " ") # This code is contributed by ipg2016107

C#

 // C# program to find K-th// smallest element in a// perfect BSTusing System;class GFG{ // A BST node public class Node {   public int key;   public Node left,               right; }; static int kth_smallest; // A utility function to// create a new BST nodepublic static Node newNode(int item){  Node temp = new Node();  temp.key = item;  temp.left = temp.right = null;  return temp;} // A utility function to// insert a new node with// given key in BSTstatic Node insert(Node node,                   int key){     // If the tree is empty  if (node == null)    return newNode(key);   // Recur down the left  // subtree for smaller values  if (key < node.key)    node.left = insert(node.left,                       key);   // Recur down the right  // subtree for smaller values  else if (key > node.key)    node.right = insert(node.right,                        key);   // Return the (unchanged)  // node pointer  return node;} // Function to find Kth Smallest// element in a perfect BSTstatic bool KSmallestPerfectBST(Node root, int k,                                int treeSize){  if (root == null)    return false;   // Find the median  // (division operation is floored)  int median_loc = (treeSize / 2) + 1;   // If the element is at  // the median  if (k == median_loc)  {    kth_smallest = root.key;    return true;  }   // calculate the number of nodes   // in the right and left sub-trees  // (division operation is floored)  int newTreeSize = treeSize / 2;   // If median is located higher  if (k < median_loc)  {    return KSmallestPerfectBST(root.left, k,                               newTreeSize);  }   // If median is located lower  int newK = k - median_loc;  return KSmallestPerfectBST(root.right, newK,                             newTreeSize);} // Driver Codepublic static void Main(String[] args){  /* Let us create following BST               50           /       \          30        70         /  \      /  \       20   40    60    80       /\   /\    /\    / \     14 25 35 45 55 65 75  85       */  Node root = null;  root = insert(root, 50);  insert(root, 30);  insert(root, 20);  insert(root, 40);  insert(root, 70);  insert(root, 60);  insert(root, 80);  insert(root, 14);  insert(root, 25);  insert(root, 35);  insert(root, 45);  insert(root, 55);  insert(root, 65);  insert(root, 75);  insert(root, 85);   int n = 15, k = 5;   // Function call  if (KSmallestPerfectBST(root,                          k, n))  {    Console.Write(kth_smallest + " ");  }}} // This code is contributed by Rajput-Ji

Javascript


Output
35

Time complexity: O(Log(N))
Auxiliary Space: O(Log(N))

My Personal Notes arrow_drop_up