B-Tree Implementation - Problem

A B-Tree is a self-balancing tree data structure that maintains sorted data and allows searches, sequential access, insertions, and deletions in logarithmic time. B-Trees are commonly used in databases and file systems.

Implement a B-Tree of order M with the following operations:

insert(key): Insert a key into the B-Tree
search(key): Search for a key in the B-Tree, return true if found
delete(key): Delete a key from the B-Tree
range_query(start, end): Return all keys in the range [start, end]

A B-Tree of order M has the following properties:

Each node has at most M children
Each internal node has at least ⌈M/2⌉ children
The root has at least 2 children (unless it's a leaf)
All leaves are at the same level
Keys in each node are stored in sorted order

Input & Output

Example 1 — Basic Operations

$ Input: operations = [["insert", 10], ["insert", 20], ["search", 10], ["range_query", 5, 25]], order = 3

› Output: [true, [10, 20]]

💡 Note: Insert 10 and 20 into B-Tree. Search for 10 returns true. Range query [5,25] returns all keys in that range: [10, 20].

Example 2 — Delete Operation

$ Input: operations = [["insert", 15], ["insert", 25], ["delete", 15], ["search", 15]], order = 3

› Output: [false]

💡 Note: Insert 15 and 25, then delete 15. Searching for 15 returns false as it was deleted.

Example 3 — Range Query

$ Input: operations = [["insert", 5], ["insert", 10], ["insert", 15], ["insert", 20], ["range_query", 8, 18]], order = 4

› Output: [[10, 15]]

💡 Note: After inserting 5, 10, 15, 20, range query [8,18] returns keys in that range: [10, 15].

Constraints

1 ≤ operations.length ≤ 1000
3 ≤ order ≤ 100
-10⁶ ≤ key ≤ 10⁶
start ≤ end for range queries

Asked in

The key insight is implementing a proper B-Tree with automatic node splitting and merging to maintain balance. The optimal approach uses a complete B-Tree implementation with logarithmic operations. Time: O(log n) per operation, Space: O(n) for the tree structure.

Common Approaches

✓ Array-Based Implementation

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

Implement B-Tree operations using a simple sorted array. This approach maintains sorted order but doesn't utilize the hierarchical structure of B-Trees.

Complete B-Tree Implementation

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

Implement a complete B-Tree with proper internal nodes, leaf nodes, splitting, merging, and all operations running in O(log n) time.

Tree-Like Array Structure

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

Create a more tree-like structure using arrays to represent nodes, implementing basic splitting when nodes overflow.

Array-Based Implementation — Algorithm Steps

Store all keys in a single sorted array
For search: linear scan through array
For insert: find position and shift elements
For delete: find and remove, shift remaining elements

Visualization

Tap to expand

Step-by-Step Walkthrough

Insert

Add key and sort entire array

Linear scan through array

Result

O(n) time for each operation

Code -

solution.c — C

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

#define MAX_KEYS 1000

int keys[MAX_KEYS];
int key_count = 0;

void insert_key(int key) {
    for (int i = 0; i < key_count; i++) {
        if (keys[i] == key) return;
    }
    keys[key_count++] = key;
    // Sort after insertion
    for (int i = 0; i < key_count - 1; i++) {
        for (int j = i + 1; j < key_count; j++) {
            if (keys[i] > keys[j]) {
                int temp = keys[i];
                keys[i] = keys[j];
                keys[j] = temp;
            }
        }
    }
}

int search_key(int key) {
    for (int i = 0; i < key_count; i++) {
        if (keys[i] == key) return 1;
    }
    return 0;
}

void delete_key(int key) {
    for (int i = 0; i < key_count; i++) {
        if (keys[i] == key) {
            for (int j = i; j < key_count - 1; j++) {
                keys[j] = keys[j + 1];
            }
            key_count--;
            break;
        }
    }
}

void range_query(int start, int end) {
    printf("[");
    int first = 1;
    for (int i = 0; i < key_count; i++) {
        if (keys[i] >= start && keys[i] <= end) {
            if (!first) printf(",");
            printf("%d", keys[i]);
            first = 0;
        }
    }
    printf("]\n");
}

int main() {
    int order;
    scanf("%d", &order);
    
    // Simple demo operations
    insert_key(10);
    insert_key(20);
    printf("%s\n", search_key(10) ? "true" : "false");
    range_query(5, 25);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Linear search, insertion, and deletion through array

⚡ Linearithmic

Space Complexity

O(n)

Single array to store all keys

⚡ Linearithmic Space

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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