# 1206. Design Skiplist

## Description

Design a Skiplist without using any built-in libraries.

A skiplist is a data structure that takes O(log(n)) time to add, erase and search. Comparing with treap and red-black tree which has the same function and performance, the code length of Skiplist can be comparatively short and the idea behind Skiplists is just simple linked lists.

For example, we have a Skiplist containing [30,40,50,60,70,90] and we want to add 80 and 45 into it. The Skiplist works this way:

Artyom Kalinin [CC BY-SA 3.0], via Wikimedia Commons

You can see there are many layers in the Skiplist. Each layer is a sorted linked list. With the help of the top layers, add, erase and search can be faster than O(n). It can be proven that the average time complexity for each operation is O(log(n)) and space complexity is O(n).

Implement the Skiplist class:

• Skiplist() Initializes the object of the skiplist.
• bool search(int target) Returns true if the integer target exists in the Skiplist or false otherwise.
• void add(int num) Inserts the value num into the SkipList.
• bool erase(int num) Removes the value num from the Skiplist and returns true. If num does not exist in the Skiplist, do nothing and return false. If there exist multiple num values, removing any one of them is fine.

Note that duplicates may exist in the Skiplist, your code needs to handle this situation.

Example 1:

Input
[[], [1], [2], [3], [0], [4], [1], [0], [1], [1]]
Output
[null, null, null, null, false, null, true, false, true, false]

Explanation
Skiplist skiplist = new Skiplist();
skiplist.search(0); // return False
skiplist.search(1); // return True
skiplist.erase(0);  // return False, 0 is not in skiplist.
skiplist.erase(1);  // return True
skiplist.search(1); // return False, 1 has already been erased.

Constraints:

• 0 <= num, target <= 2 * 104
• At most 5 * 104 calls will be made to search, add, and erase.

## Solutions

### Class Node:

• Attributes:
• val: The value stored in the node.
• next: A list of pointers to the next node at each level of the skiplist.
• __init__(self, val: int, level: int): Initializes a new node with the given value and number of levels. Each level in self.next is initially set to None.

### Class Skiplist:

• Static Attributes:
• max_level: The maximum number of levels in the skiplist.
• p: Probability factor used in determining the level of a new node.
• Instance Attributes:
• head: A dummy head node of the skiplist.
• level: The current number of levels that are in use in the skiplist.
• __init__(self): Initializes the skiplist with a dummy head node and sets the starting level to 0.

• search(self, target: int) -> bool:
• Searches for a value in the skiplist.
• Iterates from the top level down to the bottom, moving right through the levels as long as the next node’s value is less than the target.
• Returns True if the target is found, False otherwise.
• add(self, num: int) -> None:
• Inserts a value into the skiplist.
• Determines the level of the new node randomly using random_level().
• Starting from the top level, inserts the new node at the appropriate positions in the levels up to its determined level.
• erase(self, num: int) -> bool:
• Removes a value from the skiplist.
• Searches for the node from the top level down, updating links to bypass the node with the target value.
• Reduces the skiplist level if the top levels are unused after deletion.
• Returns True if the node was found and deleted, False if the node was not found.
• find_closest(self, curr: Node, level: int, target: int) -> Node:
• A helper method to find the node closest to (and less than) the target at the given level.
• random_level(self) -> int:
• Randomly determines the level for a new node based on the probability p.

### How Skiplist Works:

• Skiplist is a probabilistic data structure that uses multiple layers of sorted linked lists to ensure efficient operations.
• Higher levels of the skiplist act as “express lanes” for traversing the list, allowing skipping over large portions of the list.
• The random_level method ensures that the list remains balanced probabilistically.
• Each operation (search, add, erase) starts from the topmost level and works its way down, ensuring that operations are performed in logarithmic time on average.

### Complexity Analysis:

• Search, Insert, and Delete Operations: On average, all these operations have a time complexity of O(log n), where n is the number of elements in the skiplist.
• Space Complexity: O(n log n) on average, due to multiple levels storing references to nodes.
• class Skiplist {
private static final int MAX_LEVEL = 32;
private static final double P = 0.25;
private static final Random RANDOM = new Random();
private final Node head = new Node(-1, MAX_LEVEL);
private int level = 0;

public Skiplist() {
}

public boolean search(int target) {
for (int i = level - 1; i >= 0; --i) {
curr = findClosest(curr, i, target);
if (curr.next[i] != null && curr.next[i].val == target) {
return true;
}
}
return false;
}

int lv = randomLevel();
Node node = new Node(num, lv);
level = Math.max(level, lv);
for (int i = level - 1; i >= 0; --i) {
curr = findClosest(curr, i, num);
if (i < lv) {
node.next[i] = curr.next[i];
curr.next[i] = node;
}
}
}

public boolean erase(int num) {
boolean ok = false;
for (int i = level - 1; i >= 0; --i) {
curr = findClosest(curr, i, num);
if (curr.next[i] != null && curr.next[i].val == num) {
curr.next[i] = curr.next[i].next[i];
ok = true;
}
}
while (level > 1 && head.next[level - 1] == null) {
--level;
}
return ok;
}

private Node findClosest(Node curr, int level, int target) {
while (curr.next[level] != null && curr.next[level].val < target) {
curr = curr.next[level];
}
return curr;
}

private static int randomLevel() {
int level = 1;
while (level < MAX_LEVEL && RANDOM.nextDouble() < P) {
++level;
}
return level;
}

static class Node {
int val;
Node[] next;

Node(int val, int level) {
this.val = val;
next = new Node[level];
}
}
}

/**
* Your Skiplist object will be instantiated and called as such:
* Skiplist obj = new Skiplist();
* boolean param_1 = obj.search(target);
* boolean param_3 = obj.erase(num);
*/

• struct Node {
int val;
vector<Node*> next;
Node(int v, int level)
: val(v)
, next(level, nullptr) {}
};

class Skiplist {
public:
const int p = RAND_MAX / 4;
const int maxLevel = 32;
int level;

Skiplist() {
level = 0;
}

bool search(int target) {
for (int i = level - 1; ~i; --i) {
curr = findClosest(curr, i, target);
if (curr->next[i] && curr->next[i]->val == target) return true;
}
return false;
}

int lv = randomLevel();
Node* node = new Node(num, lv);
level = max(level, lv);
for (int i = level - 1; ~i; --i) {
curr = findClosest(curr, i, num);
if (i < lv) {
node->next[i] = curr->next[i];
curr->next[i] = node;
}
}
}

bool erase(int num) {
bool ok = false;
for (int i = level - 1; ~i; --i) {
curr = findClosest(curr, i, num);
if (curr->next[i] && curr->next[i]->val == num) {
curr->next[i] = curr->next[i]->next[i];
ok = true;
}
}
while (level > 1 && !head->next[level - 1]) --level;
return ok;
}

Node* findClosest(Node* curr, int level, int target) {
while (curr->next[level] && curr->next[level]->val < target) curr = curr->next[level];
return curr;
}

int randomLevel() {
int lv = 1;
while (lv < maxLevel && rand() < p) ++lv;
return lv;
}
};

/**
* Your Skiplist object will be instantiated and called as such:
* Skiplist* obj = new Skiplist();
* bool param_1 = obj->search(target);
* bool param_3 = obj->erase(num);
*/

• class Node:
__slots__ = ['val', 'next']

def __init__(self, val: int, level: int):
self.val = val
self.next = [None] * level

class Skiplist:
max_level = 32
p = 0.25

def __init__(self):
self.level = 0

def search(self, target: int) -> bool:
for i in range(self.level - 1, -1, -1):
curr = self.find_closest(curr, i, target)
if curr.next[i] and curr.next[i].val == target:
return True
return False

def add(self, num: int) -> None:
level = self.random_level()
node = Node(num, level)
self.level = max(self.level, level)
for i in range(self.level - 1, -1, -1):
curr = self.find_closest(curr, i, num)
if i < level:
node.next[i] = curr.next[i]
curr.next[i] = node

def erase(self, num: int) -> bool:
ok = False
for i in range(self.level - 1, -1, -1):
curr = self.find_closest(curr, i, num)
if curr.next[i] and curr.next[i].val == num:
curr.next[i] = curr.next[i].next[i]
ok = True
while self.level > 1 and self.head.next[self.level - 1] is None:
self.level -= 1
return ok

def find_closest(self, curr: Node, level: int, target: int) -> Node:
while curr.next[level] and curr.next[level].val < target:
curr = curr.next[level]
return curr

def random_level(self) -> int:
level = 1
while level < self.max_level and random.random() < self.p:
level += 1
return level

# Your Skiplist object will be instantiated and called as such:
# obj = Skiplist()
# param_1 = obj.search(target)
# param_3 = obj.erase(num)


• func init() { rand.Seed(time.Now().UnixNano()) }

const (
maxLevel = 16
p        = 0.5
)

type node struct {
val  int
next []*node
}

func newNode(val, level int) *node {
return &node{
val:  val,
next: make([]*node, level),
}
}

type Skiplist struct {
level int
}

func Constructor() Skiplist {
return Skiplist{
level: 1,
}
}

func (this *Skiplist) Search(target int) bool {
for i := this.level - 1; i >= 0; i-- {
p = findClosest(p, i, target)
if p.next[i] != nil && p.next[i].val == target {
return true
}
}
return false
}

func (this *Skiplist) Add(num int) {
level := randomLevel()
if level > this.level {
this.level = level
}
node := newNode(num, level)
for i := this.level - 1; i >= 0; i-- {
p = findClosest(p, i, num)
if i < level {
node.next[i] = p.next[i]
p.next[i] = node
}
}
}

func (this *Skiplist) Erase(num int) bool {
ok := false
for i := this.level - 1; i >= 0; i-- {
p = findClosest(p, i, num)
if p.next[i] != nil && p.next[i].val == num {
p.next[i] = p.next[i].next[i]
ok = true
}
}
for this.level > 1 && this.head.next[this.level-1] == nil {
this.level--
}
return ok
}

func findClosest(p *node, level, target int) *node {
for p.next[level] != nil && p.next[level].val < target {
p = p.next[level]
}
return p
}

func randomLevel() int {
level := 1
for level < maxLevel && rand.Float64() < p {
level++
}
return level
}

/**
* Your Skiplist object will be instantiated and called as such:
* obj := Constructor();
* param_1 := obj.Search(target);