Binary Search Tree - Problem

Implement a Binary Search Tree (BST) with the following operations:

insert(val): Insert a value into the BST
search(val): Search for a value in the BST (return true/false)
delete(val): Delete a value from the BST
inorder(): Return in-order traversal (left-root-right)
preorder(): Return pre-order traversal (root-left-right)
postorder(): Return post-order traversal (left-right-root)

You will receive a list of operations to perform on an initially empty BST. Each operation is represented as [operation, value] where operation is one of the strings above and value is the integer to operate on (omitted for traversals).

Return an array containing the results of each operation. For insert and delete, return null. For search, return boolean. For traversals, return the array of values.

Input & Output

Example 1 — Basic BST Operations

$ Input: operations = [["insert", 10], ["insert", 5], ["insert", 15], ["search", 10], ["inorder"]]

› Output: [null, null, null, true, [5, 10, 15]]

💡 Note: Insert 10 (root), insert 5 (left of 10), insert 15 (right of 10), search for 10 (found), inorder traversal gives sorted order [5, 10, 15]

Example 2 — Search and Traversal

$ Input: operations = [["insert", 8], ["insert", 3], ["insert", 12], ["search", 7], ["preorder"]]

› Output: [null, null, null, false, [8, 3, 12]]

💡 Note: Build BST with 8 as root, 3 as left child, 12 as right child. Search for 7 returns false (not found). Preorder traversal visits root first: [8, 3, 12]

Example 3 — Delete Operation

$ Input: operations = [["insert", 20], ["insert", 10], ["insert", 30], ["delete", 20], ["inorder"]]

› Output: [null, null, null, null, [10, 30]]

💡 Note: Insert 20, 10, 30. Delete root node 20 (replaced by successor 30). Final inorder traversal shows remaining nodes: [10, 30]

Constraints

1 ≤ operations.length ≤ 1000
-10⁴ ≤ val ≤ 10⁴
All values are unique when inserted

Visualization

Tap to expand

Asked in

G Google 35 a Amazon 42 M Microsoft 28 f Facebook 31

The key insight is implementing a proper Binary Search Tree with TreeNode structure that maintains the BST property (left < root < right). This enables O(log n) average time complexity for all operations instead of O(n) linear operations. Best approach uses recursive functions for insert, search, delete, and traversals. Time: O(log n) average, Space: O(log n) for recursion stack.

Common Approaches

✓ Array-Based Implementation

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

Use a simple array to store all BST values. For each operation, iterate through the array linearly to find, insert, or delete elements. Sort the array when traversals are needed.

Proper BST Implementation

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

Create a proper BST using TreeNode class with left and right pointers. Each operation uses the BST property (left < root < right) for efficient O(log n) average performance.

Array-Based Implementation — Algorithm Steps

Store all values in a single array
For insert: append to end of array
For search: linear scan through entire array
For delete: find element and shift remaining elements
For traversals: sort array first, then return in desired order

Visualization

Tap to expand

Step-by-Step Walkthrough

Insert Operation

Simply append new values to end of array

Search Operation

Linear scan through entire array to find value

Traversal

Sort array first, then return in desired order

Code -

solution.c — C

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

typedef struct {
    int* data;
    int size;
    int capacity;
} Array;

Array* createArray() {
    Array* arr = malloc(sizeof(Array));
    arr->data = malloc(100 * sizeof(int));
    arr->size = 0;
    arr->capacity = 100;
    return arr;
}

void insertArray(Array* arr, int val) {
    if (arr->size < arr->capacity) {
        arr->data[arr->size++] = val;
    }
}

bool searchArray(Array* arr, int val) {
    for (int i = 0; i < arr->size; i++) {
        if (arr->data[i] == val) return true;
    }
    return false;
}

void deleteArray(Array* arr, int val) {
    for (int i = 0; i < arr->size; i++) {
        if (arr->data[i] == val) {
            for (int j = i; j < arr->size - 1; j++) {
                arr->data[j] = arr->data[j + 1];
            }
            arr->size--;
            break;
        }
    }
}

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

int main() {
    Array* arr = createArray();
    
    // Simple implementation for demonstration
    // Would need proper JSON parsing for full solution
    
    printf("[]");
    
    free(arr->data);
    free(arr);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Each operation can take O(n) time, and with n operations total, worst case is O(n²)

⚠ Quadratic Growth

Space Complexity

O(n)

Array stores all n inserted elements

⚡ Linearithmic Space

89.0K Views

High Frequency

~35 min Avg. Time

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

Binary Search Tree - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Array-Based Implementation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler