Van Emde Boas Tree - Problem

The Van Emde Boas Tree (vEB Tree) is an advanced data structure that supports predecessor and successor queries on integers in O(log log U) time complexity, where U is the universe size.

Your task is to implement a Van Emde Boas Tree that supports the following operations:

insert(x): Insert integer x into the tree
delete(x): Remove integer x from the tree
predecessor(x): Find the largest integer less than x in the tree (-1 if none exists)
successor(x): Find the smallest integer greater than x in the tree (-1 if none exists)
contains(x): Check if integer x exists in the tree

Given a list of operations, execute them and return the results of all query operations (predecessor, successor, contains).

The universe size U is fixed at 2^16 = 65536, so all integers are in range [0, 65535].

Input & Output

Example 1 — Basic Operations

$ Input: operations = [["insert",5],["insert",10],["insert",15],["predecessor",12],["successor",12]]

› Output: [10,15]

💡 Note: Insert 5, 10, 15 into the tree. Predecessor of 12 is 10 (largest element < 12). Successor of 12 is 15 (smallest element > 12).

Example 2 — Contains Query

$ Input: operations = [["insert",8],["contains",8],["contains",9]]

› Output: [true,false]

💡 Note: Insert 8 into tree. Query contains(8) returns true, contains(9) returns false since 9 was never inserted.

Example 3 — No Predecessor

$ Input: operations = [["insert",20],["insert",30],["predecessor",15]]

› Output: [-1]

💡 Note: Tree contains 20 and 30. Predecessor of 15 doesn't exist since all elements are ≥ 15, so return -1.

Constraints

1 ≤ operations.length ≤ 1000
Each operation is one of: ["insert", x], ["delete", x], ["contains", x], ["predecessor", x], ["successor", x]
0 ≤ x ≤ 65535 (fits in 16 bits)
All query operations (contains, predecessor, successor) return results

Visualization

Tap to expand

Asked in

G Google 12 M Microsoft 8 f Facebook 6 a Amazon 5

The Van Emde Boas Tree achieves optimal O(log log U) time complexity for predecessor/successor queries through recursive square-root decomposition. The key insight is dividing universe U into √U clusters of size √U, with a summary structure tracking non-empty clusters. This creates a recursive hierarchy where each level reduces the problem size from U to √U, giving the recurrence T(U) = T(√U) + O(1) which solves to O(log log U). Best approach uses full vEB tree implementation. Time: O(log log U), Space: O(U).

Common Approaches

✓ Linear Search Array

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

Use a dynamic array to store all elements. For predecessor/successor queries, iterate through all elements to find the closest match. Simple but inefficient for large datasets.

Van Emde Boas Tree

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

The Van Emde Boas tree uses recursive square-root decomposition. For universe size U, it divides into √U clusters of size √U each, with recursive structure achieving O(log log U) time complexity.

Linear Search Array — Algorithm Steps

Store all elements in a sorted array
For predecessor: scan from right to find largest element < x
For successor: scan from left to find smallest element > x
Linear time for each query operation

Visualization

Tap to expand

Step-by-Step Walkthrough

Store Elements

Keep all elements in a sorted array

Linear Scan

Check each element one by one to find predecessor/successor

Return Result

Return the closest matching element or -1 if none found

Code -

solution.c — C

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

#define MAX_ELEMENTS 1000

int elements[MAX_ELEMENTS];
int elementCount = 0;
int results[MAX_ELEMENTS];
int resultCount = 0;

void insertElement(int x) {
    for (int i = 0; i < elementCount; i++) {
        if (elements[i] == x) return;
    }
    elements[elementCount++] = x;
    
    // Sort elements
    for (int i = 0; i < elementCount - 1; i++) {
        for (int j = 0; j < elementCount - i - 1; j++) {
            if (elements[j] > elements[j + 1]) {
                int temp = elements[j];
                elements[j] = elements[j + 1];
                elements[j + 1] = temp;
            }
        }
    }
}

void deleteElement(int x) {
    for (int i = 0; i < elementCount; i++) {
        if (elements[i] == x) {
            for (int j = i; j < elementCount - 1; j++) {
                elements[j] = elements[j + 1];
            }
            elementCount--;
            break;
        }
    }
}

int contains(int x) {
    for (int i = 0; i < elementCount; i++) {
        if (elements[i] == x) return 1;
    }
    return 0;
}

int predecessor(int x) {
    int pred = -1;
    for (int i = 0; i < elementCount; i++) {
        if (elements[i] < x && elements[i] > pred) {
            pred = elements[i];
        }
    }
    return pred;
}

int successor(int x) {
    int succ = -1;
    for (int i = 0; i < elementCount; i++) {
        if (elements[i] > x && (succ == -1 || elements[i] < succ)) {
            succ = elements[i];
        }
    }
    return succ;
}

int main() {
    // Simple implementation for demo
    // In real implementation, would parse JSON input
    
    printf("[]");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each query operation requires scanning through all n elements

✓ Linear Growth

Space Complexity

O(n)

Array stores n elements where n is number of inserted elements

⚡ Linearithmic Space

2.8K Views

Low Frequency

~45 min Avg. Time

89 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

Van Emde Boas Tree - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Linear Search Array — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler