Insert into a Binary Search Tree

Insert into a Binary Search Tree - Problem

You are given the root node of a binary search tree (BST) and a value to insert into the tree. Return the root node of the BST after the insertion.

It is guaranteed that the new value does not exist in the original BST.

Notice: There may exist multiple valid ways for the insertion, as long as the tree remains a BST after insertion. You can return any of them.

Input & Output

Example 1 — Insert into Right Subtree

$ Input: root = [4,2,7,1,3], val = 5

› Output: [4,2,7,1,3,5]

💡 Note: Start at root (4): 5 > 4 so go right to 7. At node 7: 5 < 7 so go left. Left child is null, so insert 5 there.

Example 2 — Insert into Left Subtree

$ Input: root = [40,20,60,10,30,50,70], val = 25

› Output: [40,20,60,10,30,50,70,null,null,25]

💡 Note: 25 < 40 (go left) → 25 > 20 (go right) → 25 < 30 (go left). Insert 25 as left child of 30.

Example 3 — Single Node Tree

$ Input: root = [4], val = 2

› Output: [4,2]

💡 Note: Tree has only root node 4. Since 2 < 4, insert 2 as left child of root.

Constraints

The number of nodes in the tree will be in the range [0, 10⁴]
-10⁸ ≤ Node.val ≤ 10⁸
All the values Node.val are unique
-10⁸ ≤ val ≤ 10⁸
It's guaranteed that val does not exist in the original BST

Visualization

Tap to expand

Asked in

a Amazon 42 M Microsoft 38 f Facebook 29 G Google 24

The key insight is to leverage the BST property: values smaller than current node go left, larger values go right. The optimal approach recursively navigates to the correct insertion point in O(h) time where h is tree height. Time: O(h), Space: O(h).

Common Approaches

✓ One Pass Hash

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

Brute Force (Rebuild Tree)

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

Extract all values from the tree into an array, add the new value, sort the array, and reconstruct a balanced BST from the sorted values.

Optimal BST Insertion

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

Use the BST property to navigate directly to the correct insertion point. Compare the new value with current node: go left if smaller, right if larger, until finding an empty spot.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

// Definition for a binary tree node
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

struct NodeInfo {
    bool isPerfect;
    int height;
    int size;
};

int* perfectSizes;
int sizesCount;
int sizesCapacity;

void addPerfectSize(int size) {
    if (sizesCount >= sizesCapacity) {
        sizesCapacity *= 2;
        perfectSizes = (int*)realloc(perfectSizes, sizesCapacity * sizeof(int));
    }
    perfectSizes[sizesCount++] = size;
}

struct NodeInfo dfs(struct TreeNode* node) {
    struct NodeInfo result;
    
    if (!node) {
        result.isPerfect = true;
        result.height = 0;
        result.size = 0;
        return result;
    }
    
    // Single leaf node is perfect
    if (!node->left && !node->right) {
        addPerfectSize(1);
        result.isPerfect = true;
        result.height = 1;
        result.size = 1;
        return result;
    }
    
    // Node with only one child cannot be perfect
    if (!node->left || !node->right) {
        // Still need to explore the existing subtree
        if (node->left) dfs(node->left);
        if (node->right) dfs(node->right);
        result.isPerfect = false;
        result.height = 0;
        result.size = 0;
        return result;
    }
    
    // Recursively check both subtrees
    struct NodeInfo leftInfo = dfs(node->left);
    struct NodeInfo rightInfo = dfs(node->right);
    
    // Current subtree is perfect if both children are perfect and same height
    if (leftInfo.isPerfect && rightInfo.isPerfect && 
        leftInfo.height == rightInfo.height) {
        int currentSize = leftInfo.size + rightInfo.size + 1;
        addPerfectSize(currentSize);
        result.isPerfect = true;
        result.height = leftInfo.height + 1;
        result.size = currentSize;
        return result;
    }
    
    result.isPerfect = false;
    result.height = 0;
    result.size = 0;
    return result;
}

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

int kthLargestPerfectSubtree(struct TreeNode* root, int k) {
    sizesCapacity = 1000;
    perfectSizes = (int*)malloc(sizesCapacity * sizeof(int));
    sizesCount = 0;
    
    dfs(root);
    qsort(perfectSizes, sizesCount, sizeof(int), compare);
    
    int result = (k <= sizesCount) ? perfectSizes[k - 1] : -1;
    free(perfectSizes);
    return result;
}

// Add main function for compilation
int main() {
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

87.4K Views

Medium Frequency

~15 min Avg. Time

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