Design Skiplist

Design Skiplist - Problem

🎯 Design a Skip List Data Structure

Imagine having a multi-level highway system for data! A Skip List is a brilliant data structure that achieves O(log n) performance for search, insertion, and deletion operations using nothing more than clever layered linked lists.

Your task is to implement a Skip List from scratch that supports:

Search: Find if a target value exists
Add: Insert a new value (duplicates allowed)
Erase: Remove a value and return success status

The Magic: Unlike traditional linked lists that require O(n) traversal, Skip Lists use multiple levels where higher levels act as "express lanes" to jump over many elements quickly. Each element has a random height, creating a probabilistic balanced structure.

Example: For a Skip List containing [30, 40, 50, 60, 70, 90], adding 45 and 80 would create new nodes that randomly appear in multiple levels, maintaining the sorted order at each level.

Think of it as a linked list with turbo boosters!

Input & Output

example_1.py — Basic Operations

$ Input: skiplist = Skiplist() skiplist.add(1) skiplist.add(2) skiplist.add(3) skiplist.search(0) # return False skiplist.add(4) skiplist.search(1) # return True skiplist.erase(0) # return False skiplist.erase(1) # return True skiplist.search(1) # return False

› Output: False True False True False

💡 Note: After adding 1,2,3: search(0) fails. Add 4: search(1) succeeds. erase(0) fails (not found). erase(1) succeeds. search(1) now fails.

example_2.py — Duplicate Handling

$ Input: skiplist = Skiplist() skiplist.add(5) skiplist.add(5) skiplist.add(5) skiplist.search(5) # return True skiplist.erase(5) # return True skiplist.search(5) # return True (still has duplicates) skiplist.erase(5) # return True skiplist.erase(5) # return True skiplist.erase(5) # return False

› Output: True True True True True False

💡 Note: Skip List handles duplicates correctly. After adding three 5's, each erase removes one instance until all are gone.

example_3.py — Empty List Operations

$ Input: skiplist = Skiplist() skiplist.search(1) # return False skiplist.erase(1) # return False skiplist.add(1) skiplist.search(1) # return True

› Output: False False True

💡 Note: Operations on empty Skip List work correctly. search and erase return False, but add followed by search works.

Constraints

0 ≤ num, target ≤ 2 × 10⁴
At most 5 × 10⁴ calls will be made to search, add, and erase
Duplicates are allowed in the Skip List
Performance requirement: Average O(log n) time complexity for all operations

Visualization

Tap to expand

Asked in

a Amazon 15 G Google 12 R Redis Labs 8 ⊞ Microsoft 6

The optimal Skip List implementation uses probabilistic balancing through random node heights to achieve O(log n) expected performance. Key insights: use multiple levels as express lanes, maintain sorted order at each level, and leverage randomization instead of complex tree rebalancing. This creates an elegant data structure that's simpler than balanced trees but equally efficient.

Common Approaches

✓ Proper Skip List Implementation (Optimal)

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

The true Skip List implementation uses multiple levels where each node has a random height. Higher levels act as express lanes, allowing us to skip over many elements. The key insight is using randomization to achieve balance without complex rebalancing algorithms. Each level maintains sorted order, and we traverse from top to bottom, moving right when possible and down when necessary.

Simple Linked List (Linear Search)

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

The simplest approach is to implement the Skip List as a regular sorted linked list. For search, traverse from head to find the target. For insertion, find the correct position and insert. For deletion, find the node and remove it. This gives us the basic functionality but doesn't leverage the Skip List's multi-level advantage.

Proper Skip List Implementation (Optimal) — Algorithm Steps

Create nodes with random heights using coin flips
Maintain multiple levels with proper linking
For search: start at top level, move right until too far, then drop down
For insertion: find insertion point at all levels, insert with random height
For deletion: find node at all levels and remove connections

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at Top Level

Begin search from highest level of header

Horizontal Movement

Move right while next value is less than target

Vertical Drop

Drop down one level when can't go right

Target Found

Continue until target found or confirmed absent

Code -

solution.c — C

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

#define MAX_LEVEL 16

typedef struct SkipListNode {
    int val;
    struct SkipListNode** forward;
} SkipListNode;

typedef struct {
    int level;
    SkipListNode* header;
} Skiplist;

SkipListNode* createNode(int val, int level) {
    SkipListNode* node = (SkipListNode*)malloc(sizeof(SkipListNode));
    node->val = val;
    node->forward = (SkipListNode**)calloc(level + 1, sizeof(SkipListNode*));
    return node;
}

int randomLevel() {
    int level = 0;
    while ((rand() & 1) && level < MAX_LEVEL) {
        level++;
    }
    return level;
}

Skiplist* skiplistCreate() {
    srand(time(NULL));
    Skiplist* obj = (Skiplist*)malloc(sizeof(Skiplist));
    obj->level = 0;
    obj->header = createNode(-1, MAX_LEVEL);
    return obj;
}

bool skiplistSearch(Skiplist* obj, int target) {
    SkipListNode* current = obj->header;
    
    for (int i = obj->level; i >= 0; i--) {
        while (current->forward[i] && current->forward[i]->val < target) {
            current = current->forward[i];
        }
    }
    
    current = current->forward[0];
    return current && current->val == target;
}

void skiplistAdd(Skiplist* obj, int num) {
    SkipListNode* update[MAX_LEVEL + 1];
    SkipListNode* current = obj->header;
    
    for (int i = obj->level; i >= 0; i--) {
        while (current->forward[i] && current->forward[i]->val < num) {
            current = current->forward[i];
        }
        update[i] = current;
    }
    
    int newLevel = randomLevel();
    
    if (newLevel > obj->level) {
        for (int i = obj->level + 1; i <= newLevel; i++) {
            update[i] = obj->header;
        }
        obj->level = newLevel;
    }
    
    SkipListNode* newNode = createNode(num, newLevel);
    
    for (int i = 0; i <= newLevel; i++) {
        newNode->forward[i] = update[i]->forward[i];
        update[i]->forward[i] = newNode;
    }
}

bool skiplistErase(Skiplist* obj, int num) {
    SkipListNode* update[MAX_LEVEL + 1];
    SkipListNode* current = obj->header;
    
    for (int i = obj->level; i >= 0; i--) {
        while (current->forward[i] && current->forward[i]->val < num) {
            current = current->forward[i];
        }
        update[i] = current;
    }
    
    current = current->forward[0];
    
    if (current && current->val == num) {
        for (int i = 0; i <= obj->level; i++) {
            if (update[i]->forward[i] != current) break;
            update[i]->forward[i] = current->forward[i];
        }
        
        while (obj->level > 0 && !obj->header->forward[obj->level]) {
            obj->level--;
        }
        
        free(current->forward);
        free(current);
        return true;
    }
    return false;
}

void skiplistFree(Skiplist* obj) {
    SkipListNode* current = obj->header;
    while (current) {
        SkipListNode* temp = current;
        current = current->forward[0];
        free(temp->forward);
        free(temp);
    }
    free(obj);
}

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Expected O(log n) for all operations due to probabilistic balancing through random heights

✓ Linear Growth

Space Complexity

O(n)

Linear space for nodes, with expected O(n) total pointers across all levels

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~35 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

🎯 Design a Skip List Data Structure

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Proper Skip List Implementation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler