Simple Database Engine - Problem

Build a simple key-value database engine that supports basic CRUD operations (Create, Read, Update, Delete) with efficient indexing and data persistence.

Your database engine should implement:

B-Tree indexing for fast key lookups
Disk persistence to save/load data
Basic operations: put(key, value), get(key), delete(key), list()

The engine should handle a sequence of operations and return the final state as a list of key-value pairs sorted by key.

Input & Output

Example 1 — Basic CRUD Operations

$ Input: operations = [["put","apple","red"],["put","banana","yellow"],["get","apple"],["delete","banana"],["put","cat","furry"]]

› Output: [["apple","red"],["cat","furry"]]

💡 Note: Put apple→red, put banana→yellow, get apple returns red, delete banana, put cat→furry. Final state has apple and cat sorted by key.

Example 2 — Update Existing Key

$ Input: operations = [["put","key1","value1"],["put","key1","updated"],["get","key1"]]

› Output: [["key1","updated"]]

💡 Note: Put key1→value1, then update key1→updated. Get returns updated value. Final state contains the updated pair.

Example 3 — Empty Result

$ Input: operations = [["put","temp","data"],["delete","temp"]]

› Output: []

💡 Note: Put temp→data then delete temp. Database becomes empty, so return empty array.

Constraints

1 ≤ operations.length ≤ 1000
operations[i].length is either 2 (for get/delete) or 3 (for put)
All keys and values are strings with length 1 ≤ length ≤ 100
Keys contain only lowercase letters and numbers

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 f Facebook 28

The key insight is choosing the right data structure for database operations. A hash map provides O(1) average operations but requires sorting at the end, while a B-Tree maintains sorted order and provides O(log n) operations like real databases. Best approach depends on operation frequency vs. final sorting needs. Time: O(n log n), Space: O(n).

Common Approaches

✓ B-Tree with Persistence

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

Build a complete database engine with B-Tree indexing for logarithmic search times and file persistence. This approach mimics real database systems with ordered access and durability.

Hash Map Implementation

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

Implement the database using a hash map data structure. This provides constant-time average performance for all basic operations, making it much faster than linear search.

Linear Search Array

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

Use a basic array to store all key-value pairs. For every operation, scan through the entire array to find the target key. Simple but inefficient for large datasets.

B-Tree with Persistence — Algorithm Steps

Implement B-Tree data structure for key indexing
Maintain sorted order automatically in B-Tree nodes
Add persistence layer to save/load from disk
Handle node splitting and merging for balance
Support range queries and ordered traversal

Visualization

Tap to expand

Step-by-Step Walkthrough

Tree Structure

Keys stored in sorted nodes

Navigate Path

Follow pointers down tree levels

Balanced Access

All leaves at same depth

Code -

solution.c — C

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

#define MAX_KEYS 10
#define MAX_CHILDREN 11

struct BTreeNode {
    char keys[MAX_KEYS][100];
    char values[MAX_KEYS][100];
    struct BTreeNode* children[MAX_CHILDREN];
    int keyCount;
    int isLeaf;
    int degree;
};

struct BTreeNode* createNode(int degree) {
    struct BTreeNode* node = malloc(sizeof(struct BTreeNode));
    node->keyCount = 0;
    node->isLeaf = 1;
    node->degree = degree;
    for (int i = 0; i < MAX_CHILDREN; i++) {
        node->children[i] = NULL;
    }
    return node;
}

char* search(struct BTreeNode* node, char* key) {
    int i = 0;
    while (i < node->keyCount && strcmp(key, node->keys[i]) > 0) {
        i++;
    }
    
    if (i < node->keyCount && strcmp(key, node->keys[i]) == 0) {
        return node->values[i];
    }
    
    if (node->isLeaf) {
        return NULL;
    }
    
    return search(node->children[i], key);
}

void insert(struct BTreeNode** root, char* key, char* value) {
    // Simplified B-tree insert
    if ((*root)->keyCount < MAX_KEYS) {
        int i = (*root)->keyCount - 1;
        while (i >= 0 && strcmp(key, (*root)->keys[i]) < 0) {
            strcpy((*root)->keys[i + 1], (*root)->keys[i]);
            strcpy((*root)->values[i + 1], (*root)->values[i]);
            i--;
        }
        strcpy((*root)->keys[i + 1], key);
        strcpy((*root)->values[i + 1], value);
        (*root)->keyCount++;
    }
}

void inorderTraversal(struct BTreeNode* node, char result[][2][100], int* count) {
    for (int i = 0; i < node->keyCount; i++) {
        if (!node->isLeaf) {
            inorderTraversal(node->children[i], result, count);
        }
        strcpy(result[*count][0], node->keys[i]);
        strcpy(result[*count][1], node->values[i]);
        (*count)++;
    }
    
    if (!node->isLeaf) {
        inorderTraversal(node->children[node->keyCount], result, count);
    }
}

int main() {
    printf("[]\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Each operation takes O(log n) in B-Tree, n operations total

⚠ Quadratic Growth

Space Complexity

O(n)

B-Tree nodes store all n key-value pairs with tree overhead

⚡ Linearithmic Space

23.2K Views

Medium Frequency

~45 min Avg. Time

892 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

Simple Database Engine - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

B-Tree with Persistence — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler