跳跃表(skiplist)实现及简单分析

摘要：二叉搜索树是OI中最常用的数据结构之一，然而一个好的平衡树并不好写。因此链表+更多的指针成为了一种方便的替代品。skiplist即是基于这种思想的检索数据结构。

基本参数

• 时间复杂度：所有操作期望O(lgn)；
• 空间复杂度：期望O(n)；
• 代码难度：略小于Treap；
• 灵活性：较差。

实现思想概述

网易公开课上 MIT算法导论课程中有着详细的介绍。

考虑一个地铁线路，从A1,A2,A3...An共n站。一个人想从Ai到达Aj，所需要乘坐站数是期望O(n)。现在市政府为了方便出行，新建了一些快速路线，允许快车跳过其中一些站而直接到达目的地，出行所需的期望站数会变成多少呢？

快速路线: 1-------------------------->8  (2)
快速路线: 1---------->4-------------->8  (1)
原始路线： 1-->2-->3-->4-->5-->6-->7-->8  （0）

如图，现在加入某人从1站到6站，就不需要再一站一站走，而可以从快速路(1)直接由1->4，再走原始线路即可。不难发现，如果每次建设的快速线路都平分上一条，出行的站数为O(lgn)。

现在考虑这样一种数据结构：它由若干层链表构成，最低端为第0层，存放原始数据；第i层在位置j有一个节点当且仅当i-1层也有这个节点。这样我们可以方便的定义各种二叉树操作：

1. 查找：
   从最顶端的第一个元素开始先向右试探，如果右侧值小于等于查找值，就向右转，否则向下，直到无路可走。
2. 插入：
   找到第一个比带插入元素小的元素的位置pos，用标准的链表插入法插入，再向上若干层重复插入。期间维护每一个边的长度（因为在靠上的地方一次跳跃很可能跳过很长距离）。

3. 删除：
   找到待删除元素位置pos，用标准的链表删除法删除，再向上若干层重复删除。期间维护每一个边的长度。

   注意！在插入维护过程中要记录左端点左移量left_shift,以确定新的跳跃边长度；每一次维护要维护到顶！

4. 前驱后继
   同查找

5. k大，rank
   类似查找。

细节及分析

Q：每次上移多少层？

A:据说有一种特别神奇的方法可以严格建立，但是我们有更好的解决策略——随机！每次决定是否再建一层，就抛一次硬币！
期望层数

h=∑i=1∞i2i=∑i=1∞∑j=i−1∞12j=∑i=1∞12i−1=2

由于随机建立，查找类似于随机二分查找。用T(n)表示长度为n的序列的期望查找复杂度，有

T(n)=1n∑i=1n−1T(i)=O(lgn)

Q：如何防止第一个元素变动导致查询出错？

A:存一个−∞即可。

Q：如何实现？

A:类似数组模拟邻接表的方法，加上一个down和length即可。

代码

测试题目为luogu3369，普通平衡树

#include <bits/stdc++.h>
using namespace std;

struct node {
        int dat; // dat 
        int bef, next; // pointer in line
        int down, up;      // godown & up
        int length;    // length to next
        node() 
        {
                up = down = dat = length = bef = next = 0;
                //length = 1;
        }
} skiplist[1000010];
const int MAX_STEP = 20;
int top = 0;
int lev_top = 0;

int level()
{
        int k = 0;
        while (rand()&1) k++;
        return min(MAX_STEP-1, k);
}

void push_dat_after(int nd, int dat, int down, int left_shift)
{
        int aft = skiplist[nd].next;
        skiplist[++top].dat = dat;
        skiplist[top].bef = nd;
        skiplist[top].next = aft;
        skiplist[top].down = down;    skiplist[down].up = top;
        skiplist[top].length = max(0, skiplist[nd].length-left_shift+1);
        skiplist[nd].length = left_shift; 
        skiplist[nd].next = top;
        skiplist[aft].bef = top;
} // push data after a node, with dat, down_element, and totle left_shift

void init()
{
        for (int i = 1; i <= MAX_STEP; i++) {
                skiplist[++top].down = lev_top;
                skiplist[lev_top].up = top;
                skiplist[top].dat = INT_MIN;
                lev_top = top;
        }
        // Build As -INF
}

int find_last_ls(int nd, int key)
{
        if (!nd) return nd;
        else if (skiplist[nd].next && skiplist[skiplist[nd].next].dat < key)
                return find_last_ls(skiplist[nd].next, key);
        else if (skiplist[nd].down)
                return find_last_ls(skiplist[nd].down, key);
        else    return nd;
} // pre-element

int find_first_gt(int nd, int key)
{
        if (!nd) return nd;
        else if (skiplist[nd].next && skiplist[skiplist[nd].next].dat <= key)
                return find_first_gt(skiplist[nd].next, key);
        else if (skiplist[nd].down)
                return find_first_gt(skiplist[nd].down, key);
        else    return skiplist[nd].next;
} // succ-element

void push_in(int k)
{
        int left_pos = find_last_ls(lev_top, k), left_shift = 1, down = 0;
        int lev = level()-1;
        push_dat_after(left_pos, k, down, left_shift);
        down = top;
        for (int i = 1; i <= lev; i++) {
                while (!skiplist[left_pos].up) {
                        left_pos = skiplist[left_pos].bef;
                        left_shift += skiplist[left_pos].length;
                } // split the old links to build new ones...
                left_pos = skiplist[left_pos].up;
                push_dat_after(left_pos, k, down, left_shift);
                down = top;
        }
        while (skiplist[left_pos].bef || skiplist[left_pos].up) {
                while (!skiplist[left_pos].up) 
                        left_pos = skiplist[left_pos].bef;
                left_pos = skiplist[left_pos].up;
                skiplist[left_pos].length++;
        } // let those links that dont reached by this node know...
}

bool delete_ele(int k)
{
        int pos = skiplist[find_last_ls(lev_top, k)].next;
        if (skiplist[pos].dat != k)
                return 0;
        int left_pos;
        for (int i = pos; i; i = skiplist[i].up) {
                skiplist[skiplist[i].bef].next = skiplist[i].next;
                skiplist[skiplist[i].next].bef = skiplist[i].bef;
                skiplist[skiplist[i].bef].length += skiplist[i].length-1;
                left_pos = skiplist[i].bef;
        }
        while (skiplist[left_pos].bef || skiplist[left_pos].up) {
                while (!skiplist[left_pos].up) 
                        left_pos = skiplist[left_pos].bef;
                left_pos = skiplist[left_pos].up;
                skiplist[left_pos].length--;
        } 
        return 1;
}

int find_rank(int nd, int key)
{
        if (!nd) return 0;
        if (skiplist[nd].dat == key) return 0;
        else if (skiplist[nd].next && skiplist[skiplist[nd].next].dat < key)
                return find_rank(skiplist[nd].next, key)+skiplist[nd].length;
        else if (skiplist[nd].down)
                return find_rank(skiplist[nd].down, key);
        else    return 1;
}

int find_kth(int nd, int k)
{
        if (!nd) return 0;
        if (k == 0) return skiplist[nd].dat;
        else if (skiplist[nd].next && skiplist[nd].length <= k)
                return find_kth(skiplist[nd].next, k-skiplist[nd].length);
        else
                return find_kth(skiplist[nd].down, k);
}

void println()
{
        for (int k = lev_top; k >= 1; k--) {
        for (int i = k; i; i = skiplist[i].next)
                cout << skiplist[i].dat << " --" << skiplist[i].length << "-> " ;
        cout << endl;
        }
}

int main()
{
        //freopen("output.txt", "w", stdout);
        srand(time(0));
        init();
        int n, a, x;
        cin >> n;
        int cnt = 0;
        int ord = 1;
        for (int i = 1; i <= n; i++) {
                scanf("%d%d", &a, &x);
                switch(a) {
                        case 1: push_in(x);cnt++; break;
                        case 2: if(!delete_ele(x)) {/*puts("Nothing to delete");*/} else cnt--;break;
                        case 3: if (skiplist[skiplist[find_last_ls(lev_top, x)].next].dat != x)puts("0");else printf("%d
", find_rank(lev_top, x)); break;
                        case 4: if (x <= cnt) printf("%d
", find_kth(lev_top, x)); 
                                else puts("0"); break;
                        case 5: printf("%d
", skiplist[find_last_ls(lev_top, x)].dat); break;
                        case 6: printf("%d
", skiplist[find_first_gt(lev_top, x)].dat); break;
                        case 7: println(); break;
                }
        }
        return 0;
}