高阶数据结构——跳表

1. 什么是跳表

skiplist本质上也是一种查找结构，用于解决算法中的查找问题，跟平衡搜索树和哈希表的价值是一样的，可以作为key或者key/value的查找模型。

skiplist，顾名思义，首先它是一个list。实际上，它是在有序链表的基础上发展起来的。如果是一个有序的链表，查找数据的时间复杂度是O(N)。

• 1. 假如我们每相邻两个节点升高一层，增加一个指针，让指针指向下下个节点，如上图所示。这样所有新增加的指针连成了一个新的链表，但它包含的节点个数只有原来的一半。由于新增加的指针，我们不再需要与链表中每个节点逐个进行比较了，需要比较的节点数大概只有原来的一半。
• 2. 以此类推，我们可以在第二层新产生的链表上，继续为每相邻的两个节点升高一层，增加一个指针，从而产生第三层链表。如下图c，这样搜索效率就进一步提高了。

如果我们要找上图中的19，先从cur的结点的最上层开始，下一个结点是9比19小，则到9结点的位置，继续判断，19比21小，所以应该到9的第二层再判断，比17大，cur就到了17结点的位置，继续判断，比21小，所以应该到17的第三层，最后17的next就是19，成功找到。

skiplist正是受这种多层链表的想法的启发而设计出来的。实际上，按照上面生成链表的方式，上面每一层链表的节点个数，是下面一层的节点个数的一半，这样查找过程就非常类似二分查找，使得查找的时间复杂度可以降低到O(log n)。但是这个结构在插入删除数据的时候有很大的问题，插入或者删除一个节点之后，就会打乱上下相邻两层链表上节点个数严格的2:1的对应关系。如果要维持这种对应关系，就必须把新插入的节点后面的所有节点（也包括新插入的节点）重新进行调整，这会让时间复杂度重新蜕化成O(n)。

skiplist的设计为了避免这种问题，做了一个大胆的处理，不再严格要求对应比例关系，而是插入一个节点的时候随机出一个层数。这样每次插入和删除都不需要考虑其他节点的层数，这样就好处理多了。细节过程入下图：

2. skiplist的效率

skiplist插入一个节点时随机出一个层数，这里的随机并不是完全的随机，一般跳表会设计一个最大层数maxLevel的限制，其次会设置一个多增加一层的概率p。那么计算这个随机层数的伪代码如下图：

根据前面randomLevel()的伪码，我们很容易看出，产生越高的节点层数，概率越低。定量的分析如下：

• 节点层数至少为1。而大于1的节点层数，满足一个概率分布。
• 节点层数恰好等于1的概率为1-p。
• 节点层数大于等于2的概率为p，而节点层数恰好等于2的概率为p(1-p)。
• 节点层数大于等于3的概率为p^2，而节点层数恰好等于3的概率为p^2*(1-p)。节点层数大于等于4的概率为p^3，而节点层数恰好等于4的概率为p^3*(1-p)。……

因此，一个节点的平均层数（也即包含的平均指针数目），计算如下：

现在很容易计算出：

• 当p=1/2时，每个节点所包含的平均指针数目为2；
• 当p=1/4时，每个节点所包含的平均指针数目为1.33。

跳表的平均时间复杂度为O(logN)，证明过程较复杂，有兴趣的可以去搜一下。

3. skiplist的实现

用一道题来实现skiplist。

题目链接：1206. 设计跳表 - 力扣（LeetCode）

题目描述：

我们可以先来看一下整体框架。

struct SkiplistNode
{
    int _value;    //关键字
    vector<SkiplistNode*> _nextV;  //下一个节点的数组

    SkiplistNode(int value, int leavel)
        : _value(value)
        , _nextV(leavel, nullptr)
    {

    }
};

class Skiplist {
public:
    Skiplist() {
        _head = new SkiplistNode(-1, 1);
        srand(time(0));
    }

    bool search(int target)；  //查找
    void add(int num);         //新增
    bool erase(int num);       //删除

public:
    SkiplistNode* _head;    //头节点
    size_t _maxLeavel = 32; //最大层数
    double _p = 0.25;       //增加一层的概率
};

因为我们的层数是随机的，所以要在Skiplist的构造函数添加一段随机数种子的代码。

3.1 search

bool search(int target) {
    SkiplistNode* cur = _head;  //从头节点开始判断
    int leavel = cur->_nextV.size() - 1;  //头节点的最高层
    while (leavel >= 0)
    {
        //如果比目标值小，就降一层
        if (cur->_nextV[leavel] && cur->_nextV[leavel]->_value < target)
        {
            cur = cur->_nextV[leavel];
        }
        //如果比目标值大，就向右走
        else if (cur->_nextV[leavel] == nullptr || cur->_nextV[leavel]->_value > target)
        {
            --leavel;
        }
        //找到了目标值，返回true
        else
        {
            return true;
        }
    }

    return false;
}

我们从头节点的最高层开始判断，初始位置如下。

每次与cur->_nextV[leavel]进行比较，也就是说每次都是与当前层的右边节点进行比较。如果比右边的小，说明目标就在当前节点和右边节点之间，所以我们需要降层，也就是--leavel；如果比右边的大，说明目标在右边节点的右边，我们需要向右走，也就是让cur = cur->_nextV[leavel]；

3.2 add

void add(int num)
{
    SkiplistNode* cur = _head;
    int leavel = cur->_nextV.size() - 1;
    vector<SkiplistNode*> prevV;
    prevV.resize(leavel + 1, nullptr);

    //将目标节点的前节点全部保存在prevV中
    while (leavel >= 0)
    {
        //如果比目标值小，就向右走
        if (cur->_nextV[leavel] != nullptr && cur->_nextV[leavel]->_value < num)
        {
            cur = cur->_nextV[leavel];
        }
        //如果比目标值大，说明要插入的节点就在cur右边，将cur保存起来并降层
        else if (cur->_nextV[leavel] == nullptr || cur->_nextV[leavel]->_value >= num)
        {
            prevV[leavel] = cur;
            --leavel;
        }
    }

    //获取一个随机的层数
    size_t n = RandomLeavel();
    SkiplistNode* newnode = new SkiplistNode(num, n);

    //如果n超过了当前最高层，就要更新head和prevV
    if (_head->_nextV.size() < n)
    {
        _head->_nextV.resize(n);
        prevV.resize(n, _head);
    }

    //将前后指针进行连接，插入成功
    for (size_t i = 0; i < n; i++)
    {
        newnode->_nextV[i] = prevV[i]->_nextV[i];
        prevV[i]->_nextV[i] = newnode;
    }
}

插入一个节点的过程，首先要获取这个节点的前驱节点，然后每一层进行单链表的链接就行。举个例子，如果我们要插入20这个节点，并且随机的层数是4层，我们将20前面的节点保存起来，也就是9，17和19三个节点。

但是由于当前最高节点是3（头节点的层数），而要新插入一个4层的节点，就要将头节点的最高层数改为4，然后将前面保存起来的节点和20节点的前后指针链接完成，如下图所示。

3.3 erase

bool erase(int num)
{
    SkiplistNode* cur = _head;   //头节点
    int leavel = cur->_nextV.size() - 1;  //头节点的最高层数
    vector<SkiplistNode*> prevV(leavel + 1, nullptr);  //将前一个结点保存起来

    while (leavel >= 0)
    {
        //如果右边的结点比目标值小，就向右走
        if (cur->_nextV[leavel] != nullptr && cur->_nextV[leavel]->_value < num)
        {
            cur = cur->_nextV[leavel];
        }
        //如果右边的结点比目标值大，就保存当前结点并降层
        else if (cur->_nextV[leavel] == nullptr || cur->_nextV[leavel]->_value >= num)
        {
            prevV[leavel] = cur;
            --leavel;
        }
    }

    //判断要删除的数是否存在
    if (prevV[0]->_nextV[0] == nullptr || prevV[0]->_nextV[0]->_value != num)
    {
        return false;
    }
    else
    {
        SkiplistNode* del = prevV[0]->_nextV[0]; //要删除的结点
        for (size_t i = 0; i < del->_nextV.size(); i++)
        {
            prevV[i]->_nextV[i] = del->_nextV[i];
        }
        delete del;
        return true;
    }
}

和add一样，我们需要找到要删除结点的前一个，然后将链表的指针进行修改即可，当然我们也需要先判断删除的结点是否存在，只需要判断prevV[0]的下一个是不是要删除的结点。

因为前面的代码和add一样，所以我们可以将前面的代码提取出来，写成一个函数，增大复用性。

void GetPrevV(vector<SkiplistNode*>& prevV, int num)
{
    SkiplistNode* cur = _head;   //头节点
    int leavel = cur->_nextV.size() - 1;  //头节点的最高层数
    prevV.resize(leavel + 1, nullptr);  //将前一个结点保存起来

    while (leavel >= 0)
    {
        //如果右边的结点比目标值小，就向右走
        if (cur->_nextV[leavel] != nullptr && cur->_nextV[leavel]->_value < num)
        {
            cur = cur->_nextV[leavel];
        }
        //如果右边的结点比目标值大，就保存当前结点并降层
        else if (cur->_nextV[leavel] == nullptr || cur->_nextV[leavel]->_value >= num)
        {
            prevV[leavel] = cur;
            --leavel;
        }
    }
}

bool erase(int num)
{
    vector<SkiplistNode*> prevV;
    GetPrevV(prevV, num);

    //判断要删除的数是否存在
    if (prevV[0]->_nextV[0] == nullptr || prevV[0]->_nextV[0]->_value != num)
    {
        return false;
    }
    else
    {
        SkiplistNode* del = prevV[0]->_nextV[0];
        for (size_t i = 0; i < del->_nextV.size(); i++)
        {
            prevV[i]->_nextV[i] = del->_nextV[i];
        }
        delete del;
        return true;
    }
}

3.4 RandomeLeavel

int RandomLeavel()
{
    size_t leavel = 1;
    while (rand() < RAND_MAX * _p && leavel <= _maxLeavel)
    {
        ++leavel;
    }

    return leavel;
}

获取一个随机数，方法如上，rand()的取值范围是[0，RAND_MAX]，而rand() < RAND_MAX * p的意思就是概率小于p，与前面的伪代码一样。

3.5 最终代码

struct SkiplistNode
{
    int _value;
    vector<SkiplistNode*> _nextV;

    SkiplistNode(int value, int leavel)
        : _value(value)
        , _nextV(leavel, nullptr)
    {

    }
};

class Skiplist {
public:
    Skiplist() {
        _head = new SkiplistNode(-1, 1);
        srand(time(0));
    }

    bool search(int target) {
        SkiplistNode* cur = _head;
        int leavel = cur->_nextV.size() - 1;
        while (leavel >= 0)
        {
            if (cur->_nextV[leavel] && cur->_nextV[leavel]->_value < target)
            {
                cur = cur->_nextV[leavel];
            }
            else if (cur->_nextV[leavel] == nullptr || cur->_nextV[leavel]->_value > target)
            {
                --leavel;
            }
            else
            {
                return true;
            }
        }

        return false;
    }

    void GetPrevV(vector<SkiplistNode*>& prevV, int num)
    {
        SkiplistNode* cur = _head;   //头节点
        int leavel = cur->_nextV.size() - 1;  //头节点的最高层数
        prevV.resize(leavel + 1, nullptr);  //将前一个结点保存起来

        while (leavel >= 0)
        {
            //如果右边的结点比目标值小，就向右走
            if (cur->_nextV[leavel] != nullptr && cur->_nextV[leavel]->_value < num)
            {
                cur = cur->_nextV[leavel];
            }
            //如果右边的结点比目标值大，就保存当前结点并降层
            else if (cur->_nextV[leavel] == nullptr || cur->_nextV[leavel]->_value >= num)
            {
                prevV[leavel] = cur;
                --leavel;
            }
        }
    }

    void add(int num)
    {
        vector<SkiplistNode*> prevV;
        GetPrevV(prevV, num);

        //获取一个随机的层数
        size_t n = RandomLeavel();
        SkiplistNode* newnode = new SkiplistNode(num, n);

        //如果n超过了当前最高层，就要更新head和prevV
        if (_head->_nextV.size() < n)
        {
            _head->_nextV.resize(n);
            prevV.resize(n, _head);
        }

        //将前后指针进行连接，插入成功
        for (size_t i = 0; i < n; i++)
        {
            newnode->_nextV[i] = prevV[i]->_nextV[i];
            prevV[i]->_nextV[i] = newnode;
        }
    }

    bool erase(int num)
    {
        vector<SkiplistNode*> prevV;
        GetPrevV(prevV, num);

        //判断要删除的数是否存在
        if (prevV[0]->_nextV[0] == nullptr || prevV[0]->_nextV[0]->_value != num)
        {
            return false;
        }
        else
        {
            SkiplistNode* del = prevV[0]->_nextV[0];
            for (size_t i = 0; i < del->_nextV.size(); i++)
            {
                prevV[i]->_nextV[i] = del->_nextV[i];
            }
            delete del;
            return true;
        }
    }

    int RandomLeavel()
    {
        size_t leavel = 1;
        while (rand() < RAND_MAX * _p && leavel <= _maxLeavel)
        {
            ++leavel;
        }

        return leavel;
    }

    void Print()
    {
        /*int level = _head->_nextV.size();
        for (int i = level - 1; i >= 0; --i)
        {
        Node* cur = _head;
        while (cur)
        {
        printf("%d->", cur->_val);
        cur = cur->_nextV[i];
        printf("\n");
        }*/

        SkiplistNode* cur = _head;
        while (cur)
        {
            printf("%2d\n", cur->_value);
            // 打印每个每个cur节点
            for (auto e : cur->_nextV)
            {
                printf("%2s", "↓");
            }
            printf("\n");
            cur = cur->_nextV[0];
        }
    }

    SkiplistNode* _head;
    size_t _maxLeavel = 32;
    double _p = 0.25;
};

4. 跳表的优缺点

1. skiplist相比平衡搜索树(AVL树和红黑树)对比，都可以做到遍历数据有序，时间复杂度也差不多。skiplist的优势是：a、skiplist实现简单，容易控制。平衡树增删查改遍历都更复杂。b、skiplist的额外空间消耗更低。平衡树节点存储每个值有三叉链，平衡因子/颜色等消耗。skiplist中p=1/2时，每个节点所包含的平均指针数目为2；skiplist中p=1/4时，每个节点所包含的平均指针数目为1.33；

2. skiplist相比哈希表而言，就没有那么大的优势了。相比而言a、哈希表平均时间复杂度是O(1)，比skiplist快。b、哈希表空间消耗略多一点。skiplist优势如下：a、遍历数据有序b、skiplist空间消耗略小一点，哈希表存在链接指针和表空间消耗。c、哈希表扩容有性能损耗。d、哈希表再极端场景下哈希冲突高，效率下降厉害，需要红黑树补足接力。