Design Skiplist - Practice Coding Problems

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.

Visualization

Tap to expand

Understanding the Visualization

Express Lane Start

Begin at the highest available level to skip maximum elements

Horizontal Travel

Move right on current level while next value is less than target

Drop Down

When can't go right, drop to lower level for more precision

Target Reached

Continue until target found at level 0 or confirmed absent

Key Takeaway

🎯 Key Insight: Skip Lists use randomization to create a naturally balanced multi-level structure, achieving tree-like performance with linked list simplicity!

Time & Space Complexity

Time Complexity

⏱️

O(log n)

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

⚡ Linearithmic

Space Complexity

O(n)

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

⚡ Linearithmic Space

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

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

Approach	Time	Space	Notes
✓ Simple Linked List (Linear Search)	O(n)	O(n)	Use a single sorted linked list for all operations
Proper Skip List Implementation (Optimal)	O(log n)	O(n)	Multi-level probabilistic data structure with O(log n) operations

Simple Linked List (Linear Search) — Algorithm Steps

Maintain a single linked list in sorted order
For search: traverse from head until target found or exceeded
For add: find insertion point and create new node
For erase: find target node and unlink it

Visualization

Tap to expand

Step-by-Step Walkthrough

Search Start

Begin traversal from head node

Linear Traversal

Visit each node sequentially

Target Found/Insert

Found target or insertion point

Code -

solution.c — C

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

typedef struct ListNode {
    int val;
    struct ListNode* next;
} ListNode;

typedef struct {
    ListNode* head;
} Skiplist;

Skiplist* skiplistCreate() {
    Skiplist* obj = (Skiplist*)malloc(sizeof(Skiplist));
    obj->head = (ListNode*)malloc(sizeof(ListNode));
    obj->head->val = -1;
    obj->head->next = NULL;
    return obj;
}

bool skiplistSearch(Skiplist* obj, int target) {
    ListNode* curr = obj->head->next;
    while (curr) {
        if (curr->val == target) return true;
        if (curr->val > target) return false;
        curr = curr->next;
    }
    return false;
}

void skiplistAdd(Skiplist* obj, int num) {
    ListNode* prev = obj->head;
    ListNode* curr = obj->head->next;
    
    while (curr && curr->val < num) {
        prev = curr;
        curr = curr->next;
    }
    
    ListNode* newNode = (ListNode*)malloc(sizeof(ListNode));
    newNode->val = num;
    newNode->next = curr;
    prev->next = newNode;
}

bool skiplistErase(Skiplist* obj, int num) {
    ListNode* prev = obj->head;
    ListNode* curr = obj->head->next;
    
    while (curr) {
        if (curr->val == num) {
            prev->next = curr->next;
            free(curr);
            return true;
        }
        if (curr->val > num) return false;
        prev = curr;
        curr = curr->next;
    }
    return false;
}

void skiplistFree(Skiplist* obj) {
    ListNode* curr = obj->head;
    while (curr) {
        ListNode* temp = curr;
        curr = curr->next;
        free(temp);
    }
    free(obj);
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Must traverse up to n nodes for each operation in worst case

✓ Linear Growth

Space Complexity

O(n)

Only stores one node per element

⚡ Linearithmic Space

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

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Simple Linked List (Linear Search) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler