Red-Black Tree - Problem

Implement a Red-Black Tree data structure with the following operations:

insert(value) - Insert a value while maintaining RB-Tree properties
delete(value) - Delete a value while maintaining RB-Tree properties
search(value) - Search for a value in the tree

A Red-Black Tree must maintain these five properties:

Every node is either red or black
The root is always black
All leaves (NIL nodes) are black
Red nodes cannot have red children (no two red nodes are adjacent)
Every path from root to leaf contains the same number of black nodes

Return the final tree structure as an array representation after all operations.

Input & Output

Example 1 — Basic Insert Operations

$ Input: operations = [["insert",5],["insert",3],["insert",7],["search",3]]

› Output: [5,3,7]

💡 Note: Insert 5 as root (black), insert 3 and 7 as red children. Tree maintains RB properties with root black and balanced structure.

Example 2 — Multiple Operations

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

› Output: [10,5,15,3]

💡 Note: Build a balanced RB-tree with multiple inserts. Colors are assigned to maintain all five RB-tree properties.

Example 3 — Single Node

$ Input: operations = [["insert",42],["search",42]]

› Output: [42]

💡 Note: Single node tree with root colored black, satisfying all RB-tree properties.

Constraints

1 ≤ operations.length ≤ 10³
operations[i] is one of ["insert", val], ["delete", val], or ["search", val]
1 ≤ val ≤ 10⁴
Tree maintains all five Red-Black properties

Visualization

Tap to expand

Asked in

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

The key insight is implementing a self-balancing binary search tree with color properties. Red-Black trees use rotations and recoloring to maintain balance after insertions and deletions. Best approach uses proper RB-tree implementation with fixup procedures. Time: O(log n), Space: O(n)

Common Approaches

✓ Naive Binary Search Tree

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

Implement operations as a standard binary search tree without any balancing mechanisms. Insert nodes by comparing values, delete by standard BST deletion, and search by traversing left/right based on comparisons.

Red-Black Tree Implementation

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

Implement a proper Red-Black tree with rotations and recoloring to maintain balance. Each node has a color (red/black) and operations maintain the five RB-tree properties through fixup procedures.

Naive Binary Search Tree — Algorithm Steps

Insert: Compare values and go left/right until finding empty spot
Delete: Find node, handle 3 cases (leaf, one child, two children)
Search: Traverse left/right based on value comparison

Visualization

Tap to expand

Step-by-Step Walkthrough

Insert Operations

Insert nodes using standard BST rules

Unbalanced Structure

Tree becomes skewed, degrading performance

Final Result

Linear structure in worst case

Code -

solution.c — C

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

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

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

struct TreeNode* insert(struct TreeNode* node, int val) {
    if (!node) return createNode(val);
    if (val < node->val) {
        node->left = insert(node->left, val);
    } else {
        node->right = insert(node->right, val);
    }
    return node;
}

int search(struct TreeNode* node, int val) {
    if (!node) return 0;
    if (node->val == val) return 1;
    if (val < node->val) return search(node->left, val);
    return search(node->right, val);
}

struct TreeNode* findMin(struct TreeNode* node) {
    while (node->left) node = node->left;
    return node;
}

struct TreeNode* deleteNode(struct TreeNode* node, int val) {
    if (!node) return NULL;
    if (val < node->val) {
        node->left = deleteNode(node->left, val);
    } else if (val > node->val) {
        node->right = deleteNode(node->right, val);
    } else {
        if (!node->left) return node->right;
        if (!node->right) return node->left;
        struct TreeNode* minNode = findMin(node->right);
        node->val = minNode->val;
        node->right = deleteNode(node->right, minNode->val);
    }
    return node;
}

void printArray(struct TreeNode* root) {
    if (!root) {
        printf("[]\n");
        return;
    }
    
    struct TreeNode* queue[1000];
    int front = 0, rear = 0;
    queue[rear++] = root;
    
    printf("[");
    int first = 1;
    
    while (front < rear) {
        struct TreeNode* current = queue[front++];
        if (current) {
            if (!first) printf(",");
            printf("%d", current->val);
            first = 0;
            queue[rear++] = current->left;
            queue[rear++] = current->right;
        }
    }
    printf("]\n");
}

int main() {
    struct TreeNode* root = NULL;
    printArray(root);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Tree height can be O(n) in worst case when nodes are inserted in sorted order

✓ Linear Growth

Space Complexity

O(n)

Storage for n nodes plus O(n) recursion stack in worst case

⚡ Linearithmic Space

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

Red-Black Tree - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Naive Binary Search Tree — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler