跳跃表(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层也有这个节点。这样我们可以方便的定义各种二叉树操作：

查找：

从最顶端的第一个元素开始先向右试探，如果右侧值小于等于查找值，就向右转，否则向下，直到无路可走。

插入：

找到第一个比带插入元素小的元素的位置pos，用标准的链表插入法插入，再向上若干层重复插入。期间维护每一个边的长度（因为在靠上的地方一次跳跃很可能跳过很长距离）。

删除：

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

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

前驱后继

同查找

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\n", find_rank(lev_top, x)); break;
case 4: if (x <= cnt) printf("%d\n", find_kth(lev_top, x));
else puts("0"); break;
case 5: printf("%d\n", skiplist[find_last_ls(lev_top, x)].dat); break;
case 6: printf("%d\n", skiplist[find_first_gt(lev_top, x)].dat); break;
case 7: println(); break;
}
}
return 0;
}