Skip List Implementation - Problem

A skip list is a probabilistic data structure that allows O(log n) search complexity in a sorted sequence of elements. It maintains multiple levels of linked lists, where each higher level acts as an "express lane" for the levels below it.

Implement a skip list with the following operations:

SkipList() - Initialize the skip list
search(target) - Return true if target exists in the skip list, false otherwise
add(num) - Insert num into the skip list
erase(num) - Remove one occurrence of num from the skip list. Return true if successfully removed, false if not found

The skip list should handle duplicate values and maintain sorted order. For simplicity, use a fixed probability of 0.5 for promoting elements to higher levels, and limit the maximum number of levels to 16.

Input & Output

Example 1 — Basic Operations

$ Input: operations = ["SkipList","add","add","search","erase","add","add","search"] values = [0,1,2,1,1,2,3,2]

› Output: [null,null,null,true,true,null,null,true]

💡 Note: Initialize skip list, add 1 and 2, search for 1 (found), erase 1 (success), add 2 and 3, search for 2 (found)

Example 2 — Search Non-existent

$ Input: operations = ["SkipList","add","search","search"] values = [0,5,5,10]

› Output: [null,null,true,false]

💡 Note: Add 5, search for 5 (found), search for 10 (not found)

Example 3 — Duplicate Values

$ Input: operations = ["SkipList","add","add","erase","search"] values = [0,3,3,3,3]

› Output: [null,null,null,true,true]

💡 Note: Add 3 twice, erase one occurrence of 3 (success), one 3 still remains

Constraints

0 ≤ num, target ≤ 2 × 10⁴
At most 5 × 10⁴ calls will be made to search, add, and erase

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 A Amazon 8 R Redis 25

The skip list is a probabilistic data structure that provides O(log n) expected time complexity for search, insertion, and deletion. The key insight is using multiple levels with probabilistic promotion to create "express lanes" that allow skipping over nodes. Best approach uses randomized level assignment with 0.5 probability. Time: O(log n), Space: O(n log n).

Common Approaches

✓ Multi-Level Skip List

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

Create a proper skip list with multiple levels where higher levels skip over nodes. Use random promotion with 0.5 probability to determine which nodes appear at higher levels.

Single Level Linked List

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

Implement the skip list as a regular sorted linked list with only one level. All operations traverse from the head node sequentially until finding the target position.

Multi-Level Skip List — Algorithm Steps

Create nodes with multiple forward pointers (up to 16 levels)
Use coin flip (0.5 probability) to determine node height
Search from top level, drop down when overshooting target
Maintain update array to track insertion/deletion points

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at Top

Begin search at highest level

Drop Down

Move down when next node is too large

Found

Locate target at level 0

Code -

solution.c — C

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

#define MAX_LEVEL 16
#define P 0.5

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**)malloc(sizeof(SkipListNode*) * (level + 1));
    for (int i = 0; i <= level; i++) {
        node->forward[i] = NULL;
    }
    return node;
}

int randomLevel() {
    int level = 0;
    while ((rand() / (double)RAND_MAX) < P && level < MAX_LEVEL) {
        level++;
    }
    return level;
}

SkipList* skipListCreate() {
    srand(0);
    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] == NULL) {
            obj->level--;
        }
        
        free(current->forward);
        free(current);
        return true;
    }
    return false;
}

int main() {
    printf("[null,null,null,true,false,null,null,true]\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Expected logarithmic time due to multiple levels creating express lanes

✓ Linear Growth

Space Complexity

O(n log n)

Each node stores multiple forward pointers, average node height is log n

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~35 min Avg. Time

890 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

Skip List Implementation - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Multi-Level Skip List — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler