Kth Smallest Element in a BST - Practice Coding Problems

Kth Smallest Element in a BST - Problem

Given the root of a binary search tree and an integer k, your task is to find and return the k^th smallest value among all node values in the tree (using 1-based indexing).

A Binary Search Tree (BST) is a special tree where for every node, all values in the left subtree are smaller, and all values in the right subtree are larger than the node's value. This property gives us powerful traversal techniques!

Goal: Efficiently locate the k^th smallest element without necessarily examining all nodes.
Input: Root of a BST and integer k
Output: The k^th smallest value in the tree

Input & Output

example_1.py — Basic BST

$ Input: root = [3,1,4,null,2], k = 1

› Output: 1

💡 Note: The inorder traversal of the BST gives us [1,2,3,4]. The 1st smallest element is 1.

example_2.py — Larger BST

$ Input: root = [5,3,6,2,4,null,null,1], k = 3

› Output: 3

💡 Note: The inorder traversal yields [1,2,3,4,5,6]. The 3rd smallest element is 3.

example_3.py — Single Node

$ Input: root = [1], k = 1

› Output: 1

💡 Note: Tree has only one node, so the 1st (and only) smallest element is 1.

Visualization

Tap to expand

Understanding the Visualization

Start at Root

Begin traversal from the root of the BST

Go Left First

Always visit left subtree first (smaller values)

Process Current

Visit current node and increment counter

Go Right Next

Then visit right subtree (larger values)

Stop at k

Return value when counter reaches k

Key Takeaway

🎯 Key Insight: BST inorder traversal naturally produces sorted order, allowing us to stop at exactly the kth element without examining the entire tree!

Time & Space Complexity

Time Complexity

⏱️

O(H + k)

Where H is tree height. We go down H levels, then visit at most k nodes in inorder

✓ Linear Growth

Space Complexity

O(H)

O(H) for recursion stack or iterative stack, where H is tree height

✓ Linear Space

Constraints

The number of nodes in the tree is n
1 ≤ k ≤ n ≤ 10⁴
0 ≤ Node.val ≤ 10⁴
The tree is guaranteed to be a valid BST
k is guaranteed to be valid (1 ≤ k ≤ number of nodes)

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses inorder traversal of the BST, which naturally visits nodes in ascending order. By keeping a counter and stopping at the k^th node, we achieve O(H + k) time complexity where H is tree height, making it much more efficient than collecting and sorting all values.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Collect All + Sort)	O(n log n)	O(n)	Collect all node values, sort them, then return the kth element
Inorder Traversal (Optimal)	O(H + k)	O(H)	Use inorder traversal to visit nodes in sorted order, stop at kth element

Brute Force (Collect All + Sort) — Algorithm Steps

Perform any tree traversal (preorder, postorder, or level-order) to collect all values
Store all values in an array or list
Sort the collected values
Return the element at index k-1 (since we want 1-indexed result)

Visualization

Tap to expand

Step-by-Step Walkthrough

Collect All Values

Traverse the tree using any method to gather all node values

Sort Array

Sort the collected values in ascending order

Return kth Element

Access the element at index k-1 for the kth smallest value

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

void collectValues(struct TreeNode* node, int* values, int* size) {
    if (!node) return;
    values[(*size)++] = node->val;
    collectValues(node->left, values, size);
    collectValues(node->right, values, size);
}

int kthSmallest(struct TreeNode* root, int k) {
    int values[10000];  // Assuming max 10000 nodes
    int size = 0;
    collectValues(root, values, &size);
    qsort(values, size, sizeof(int), compare);
    return values[k - 1];
}

int main() {
    printf("Brute force solution ready\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n) to traverse tree + O(n log n) to sort the collected values

⚡ Linearithmic

Space Complexity

O(n)

O(n) for storing all values + O(log n) for recursion stack

⚡ Linearithmic Space

Constraints

The number of nodes in the tree is n
1 ≤ k ≤ n ≤ 10⁴
0 ≤ Node.val ≤ 10⁴
The tree is guaranteed to be a valid BST
k is guaranteed to be valid (1 ≤ k ≤ number of nodes)

78.0K Views

High Frequency

~15 min Avg. Time

2.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Collect All + Sort) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler