入门力扣自学笔记104 C++ （题目编号1206）（未理解）

1206. 设计跳表

题目：

不使用任何库函数，设计一个 跳表 。

跳表 是在 O(log(n)) 时间内完成增加、删除、搜索操作的数据结构。跳表相比于树堆与红黑树，其功能与性能相当，并且跳表的代码长度相较下更短，其设计思想与链表相似。

例如，一个跳表包含 [30, 40, 50, 60, 70, 90] ，然后增加 80、45 到跳表中。

跳表中有很多层，每一层是一个短的链表。在第一层的作用下，增加、删除和搜索操作的时间复杂度不超过 O(n)。跳表的每一个操作的平均时间复杂度是 O(log(n))，空间复杂度是 O(n)。

了解更多 : https://en.wikipedia.org/wiki/Skip_list

在本题中，你的设计应该要包含这些函数：

bool search(int target) : 返回target是否存在于跳表中。
void add(int num): 插入一个元素到跳表。
bool erase(int num): 在跳表中删除一个值，如果 num 不存在，直接返回false. 如果存在多个 num ，删除其中任意一个即可。
注意，跳表中可能存在多个相同的值，你的代码需要处理这种情况。

---

示例 1:

输入
["Skiplist", "add", "add", "add", "search", "add", "search", "erase", "erase", "search"]
[[], [1], [2], [3], [0], [4], [1], [0], [1], [1]]
输出
[null, null, null, null, false, null, true, false, true, false]

解释
Skiplist skiplist = new Skiplist();
skiplist.add(1);
skiplist.add(2);
skiplist.add(3);
skiplist.search(0);   // 返回 false
skiplist.add(4);
skiplist.search(1);   // 返回 true
skiplist.erase(0);    // 返回 false，0 不在跳表中
skiplist.erase(1);    // 返回 true
skiplist.search(1);   // 返回 false，1 已被擦除

---

提示:

0 <= num, target <= 2 * 104
调用search, add,  erase操作次数不大于 5 * 104 

---

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/design-skiplist
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

---

思路：

没看太明白，原题目中有动态图解从而来更加直观的表述该问题。

---

代码：

static constexpr int LEVEL_LIMIT = 16;

struct Node {
    int val;
    Node *next[LEVEL_LIMIT];
    Node(int node_value = -1) 
        : val(node_value),
        next{nullptr}
    {
    }
};

class Skiplist {
public:
    Skiplist() : max_level(0), dummy() {
    }
    
    bool search(int target) {
        return node_cnt.count(target);
    }
    
    void add(int num) {
        if (node_cnt.count(num)) {
            node_cnt[num]++;
            return ;
        }
        node_cnt[num]++;
        
        //path[i] is the last node with val less than num in level i
        Node *new_node = new Node(num);
        vector<Node*> path(max_level + 2, nullptr);
        Node *pre = &dummy;
        for (int i = max_level; i >= 0; i--) {
            while (pre->val < num && pre->next[i] != nullptr && pre->next[i]->val < num) {
                pre = pre->next[i];
            }
            path[i] = pre;
        }

        //rise with probability 50%
        //highest level that can be risen to is max_level + 1
        int n = min(max_level + 1, LEVEL_LIMIT - 1);
        for (int i = 0; i <= n; ++i) {
            if (i <= max_level) {
                new_node->next[i] = path[i]->next[i];
                path[i]->next[i] = new_node;
            }
            else {
                //path[0] id dummy
                if (path[0]->val == -1) {
                    dummy.next[max_level + 1] = new_node;
                }
                else {
                    Node *& first_node = dummy.next[0];
                    dummy.next[max_level + 1] = first_node;
                    first_node->next[max_level + 1] = new_node;
                } 
                max_level++;
            }
            
            if ((i >= max_level || path[i]->val != -1) && (rand() % 100) < 50) {
                break;
            }
        }
    }
    
    bool erase(int num) {
        //num doesnt exist
        if (!node_cnt.count(num)) {
            return false;
        }

        node_cnt[num]--;
        if (node_cnt[num] > 0) {
            return true;
        }
        if (node_cnt[num] == 0) {
            node_cnt.erase(num);
        } 

        //path[i] is the last node with val less than num in level i
        vector<Node*> path(max_level + 1, nullptr);
        Node *pre = &dummy;
        Node *node_to_erase = nullptr;
        for (int i = max_level; i >= 0; i--) {
            while (pre->val < num && pre->next[i] != nullptr && pre->next[i]->val < num) {
                pre = pre->next[i];
            }

            if (pre->next[i] != nullptr && pre->next[i]->val == num) {
                node_to_erase = pre->next[i];
                path[i] = pre->next[i];
            }
        }

        if (node_to_erase == nullptr) {
            return false;
        }
        else {
            for (int i = 0; i <= max_level; ++i) {
                if (path[i] == nullptr) {
                    break;
                }
                path[i]->next[i] = node_to_erase->next[i];
            }
            //delete node_to_erase;

            return true;
        }
    }

private:
    int max_level;
    Node dummy;
    unordered_map<int,int> node_cnt;
};

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