Kth Smallest Element in a BST

Kth Smallest Element in a BST - Problem

Given the root of a binary search tree and an integer k, return the k-th smallest value (1-indexed) of all the values of the nodes in the tree.

A binary search tree (BST) is a tree where for every node, all values in the left subtree are smaller than the node's value, and all values in the right subtree are greater than the node's value.

Follow up: If the BST is modified frequently (insertions and deletions), how would you optimize the solution?

Input & Output

Example 1 — Basic BST

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

› Output: 1

💡 Note: The BST has values [1,2,3,4] in sorted order. The 1st smallest value is 1.

Example 2 — Find 3rd Smallest

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

› Output: 3

💡 Note: The sorted values are [1,2,3,4,5,6]. The 3rd smallest value is 3.

Example 3 — Single Node

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

› Output: 1

💡 Note: Only one node exists, so the 1st smallest is 1.

Constraints

The number of nodes in the tree is n.
1 ≤ k ≤ n ≤ 10⁴
0 ≤ Node.val ≤ 10⁴

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 f Facebook 6

The key insight is that in-order traversal of a BST visits nodes in sorted order. We can use this property to find the k-th smallest element efficiently by counting nodes during traversal and stopping when we reach the k-th node. Best approach is In-Order Traversal with Time: O(h + k), Space: O(h).

Common Approaches

✓ Backtracking

⏱️ Time: N/A Space: N/A

Collect All Values Then Sort

⏱️ Time: O(n log n) Space: O(n)

First, traverse the entire binary search tree and collect all node values into an array. Then sort this array and return the element at index k-1. This approach doesn't take advantage of the BST property.

In-Order Traversal with Counter

⏱️ Time: O(h + k) Space: O(h)

Perform in-order traversal of the BST, which naturally visits nodes in ascending order due to BST property. Keep a counter and return the value when counter reaches k. This is optimal and stops as soon as we find the answer.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

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

static int count;
static int result;

void inorder(struct TreeNode* root, int k) {
    if (!root || count >= k) return;
    
    inorder(root->left, k);
    
    count++;
    if (count == k) {
        result = root->val;
        return;
    }
    
    inorder(root->right, k);
}

struct TreeNode* createNode(int val) {
    struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

struct TreeNode* buildTree(char* arr) {
    if (!arr || strlen(arr) <= 2) return NULL;
    
    // Parse array format [val1,val2,val3,...]
    static struct TreeNode* nodes[1000];
    static char* tokens[1000];
    int nodeCount = 0;
    int tokenCount = 0;
    
    // Extract tokens between brackets
    char* start = strchr(arr, '[');
    char* end = strchr(arr, ']');
    if (!start || !end) return NULL;
    
    start++; // skip '['
    *end = '\0'; // null terminate before ']'
    
    // Tokenize by comma
    char* token = strtok(start, ",");
    while (token && tokenCount < 1000) {
        tokens[tokenCount++] = token;
        token = strtok(NULL, ",");
    }
    
    if (tokenCount == 0) return NULL;
    
    // Create nodes array
    for (int i = 0; i < tokenCount; i++) {
        if (strcmp(tokens[i], "null") == 0) {
            nodes[i] = NULL;
        } else {
            nodes[i] = createNode(atoi(tokens[i]));
            nodeCount++;
        }
    }
    
    // Build tree using level-order relationship
    for (int i = 0; i < tokenCount; i++) {
        if (nodes[i]) {
            int leftIdx = 2 * i + 1;
            int rightIdx = 2 * i + 2;
            
            if (leftIdx < tokenCount) {
                nodes[i]->left = nodes[leftIdx];
            }
            if (rightIdx < tokenCount) {
                nodes[i]->right = nodes[rightIdx];
            }
        }
    }
    
    return nodes[0];
}

int kthSmallest(struct TreeNode* root, int k) {
    count = 0;
    result = 0;
    inorder(root, k);
    return result;
}

int main() {
    char line[10000];
    int k;
    
    // Read tree array
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    // Read k
    scanf("%d", &k);
    
    struct TreeNode* root = buildTree(line);
    int answer = kthSmallest(root, k);
    printf("%d\n", answer);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

255.0K Views

High Frequency

~15 min Avg. Time

8.5K 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