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

最新推荐文章于 2024-09-25 20:34:41 发布

OIljt12138

最新推荐文章于 2024-09-25 20:34:41 发布

阅读量819

点赞数

分类专栏： ---数据结构--- 平衡树文章标签：数据结构 noip

本文链接：https://blog.csdn.net/OIljt12138/article/details/53523430

版权

---数据结构--- 同时被 2 个专栏收录

22 篇文章 0 订阅

订阅专栏

平衡树

6 篇文章 0 订阅

订阅专栏

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

基本参数

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

实现思想概述

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

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

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

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

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

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

注意！在插入维护过程中要记录左端点左移量left_shift,以确定新的跳跃边长度；每一次维护要维护到顶！
前驱后继
同查找
k大，rank
类似查找。

细节及分析

Q：每次上移多少层？

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

h = \sum i = 1 \infty i 2 i = \sum i = 1 \infty \sum j = i - 1 \infty 1 2 j = \sum i = 1 \infty 1 2 i - 1 = 2

$h = \sum_{i = 1}^\infty \frac{i}{2^i}\\ = \sum_{i=1}^\infty \sum_{j = i-1}^\infty \frac{1}{2^j}\\ = \sum_{i=1}^\infty \frac{1}{2^{i-1}} \\=2$

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

T (n) = 1 n \sum i = 1 n - 1 T (i) = O (lg n)

$T(n) = \frac{1}{n}\sum_{i=1}^{n-1} T(i) = O(\lg n)$

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

A:存一个 $-\infty$ 即可。

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;
}