跳表的实现

上课的时候第一次听说跳表这种数据结构。跳表的出现主要是为了提升顺序链表的查找速度（因为顺序链表不能用二分查找）。实现跳表的思路还是很简单的，就是在链表的基础上，构建一个链表元素的索引，比如下面这个链表：

value:1   value:2   value:3   ......   vlaue:n
pointer-->pointer-->pointer-->......-->pointer-->NULL

以上面这个链表为基础构建的跳表中的一种是这样的：

    HEAD-->value:2               
           pNext -------------------------------> NULL
           pDown                
             |           
             V           
           value:2
           pNext -------------------------------> NULL
           pDown
             |
             V
value:1    value:2    value:3    ...    vlaue:n
pNext ---> pNext ---> pNext -->  ...--> pNext --> NULL
pDown:NULL pDown:NULL pDown:NULL        pDown:NULL

可以看到，这里将value = 2的节点的“层数”提高到了3层，而其它的元素仍然为1层，查找时，从HEAD指针指向的value = 2 的节点开始，如果带查找的元素大于2，就到2的右边查找；反之就到左边查找，起到一个类似二分查找的作用。

代码如下：

#pragma once
#include<stdlib.h>
#include<iostream>
#include<ctime>
using namespace std;
#define MAX_LEVEL 4
#define MIN 0
#define myCalloc(n) (NODE*)calloc(n,sizeof(NODE))
#define NEXT(p) p + 1

跳表节点定义：

typedef struct node{
    int dat;
    struct node * pNext;
    struct node * pDown;
}NODE;

跳表类定义：

class skipList{
private:
    NODE * pSkipL;
    int higest;
    int random();
    void insert(int value, int level);
    void myRecalloc(NODE*&p, int  n);
public:
    skipList();
    ~skipList();
    void buildSkipList(int * arr, int arrSize);
    void insert(int value);
    void delElement(int value);
    void search(int value);

};

构造/析构函数：

skipList::skipList(){
    pSkipL = NULL;
    higest = 1;
}
skipList::~skipList(){
    if (pSkipL != NULL){
        try{
            free(pSkipL);
        }
        catch (char * e){
            cout << e << endl;
        }
    }
}

根据输入的数组初始化跳表：

void skipList::buildSkipList( int * arr, int arrSize){
    int level;
    srand(time(0));
    for (int i = 0; i < arrSize; i++){
        level = random();
        cout << level << endl;
        if (pSkipL == NULL){
            //如果是第一次创建跳表，需要生成当前最高层数的头节点
            pSkipL = myCalloc(MAX_LEVEL);
            higest = MAX_LEVEL;
            //将头节点用pDown指针连起来
            for (int j = 0; j < MAX_LEVEL - 1; j++){
                pSkipL[j].dat = MIN;
                pSkipL[j].pNext = NULL;
                pSkipL[j].pDown = NEXT(pSkipL + j);
            }
            //最后一个特殊处理
            pSkipL[MAX_LEVEL - 1].dat = MIN;
            pSkipL[MAX_LEVEL - 1].pDown = NULL;
        }
        insert(arr[i], level);
    }
}

往队列中插入一个元素，插入时若该元素有多层，应该注意上层之间的链接：

void skipList::insert( int value, int level){
    NODE *p = myCalloc(level);
    int tempLevel = higest;
    NODE *pTemp = pSkipL;
    //生成一个存储value元素，层数为level的元素列
    for (int i = 0; i < level - 1; i++){
        p[i].dat = value;
        p[i].pDown = NEXT(p + i);
        p[i].pNext = NULL;
    }
    p[level - 1].dat = value;
    p[level - 1].pDown = NULL;
    p[level - 1].pNext = NULL;

    //搜索跳表，找到插入位置
    while (pTemp != NULL){
        if (tempLevel > level){
            //当前所在层数高于带插入元素列的层数，直接进入下一行
            pTemp = pTemp->pDown;
            tempLevel--;
        }
        else{
            //当前所在层数小于或等于待插入元素列的层数
            while (pTemp->pNext != NULL && pTemp->pNext->dat < p->dat){
                //横向搜索插入位置
                pTemp = pTemp->pNext;
            }
            if (pTemp->pNext != NULL&&pTemp->pNext->dat == p->dat){
                cout << "Already exist" << endl;
                break;//跳表中已有该元素，跳出搜索循环（最外层while）
            }
            else {
                //下一个元素大于待插入元素或者没有下一个元素，开始插入
                NODE* t = pTemp->pNext;
                pTemp->pNext = p + (level - tempLevel);//由于初始化的原因，下标大的是低层
                pTemp->pNext->dat = value;
                p[level - tempLevel].pNext = t;
                //进入下一行
                pTemp = pTemp->pDown;
            }
            tempLevel--;
        }   
    }
}
void skipList::insert(int value){
    int level = random();
    cout << level << endl;
    insert(value, level);
}

删除跳表中的元素，麻烦的地方是删除整列的元素：

void skipList::delElement(int value){
    NODE * temp = pSkipL;
    while (temp != NULL){
        while (temp->pNext != NULL && value > temp->pNext->dat){
            temp = temp->pNext;
        }
        if (temp->pNext != NULL && temp->pNext->dat == value){
            //第一次碰到待删除元素,开始删除，函数出口在外层while循环内
            NODE*t1 = temp->pNext;
            int level = 0;
            while (t1 != NULL){
                t1 = t1->pDown;
                level++;
            }
            t1 = temp->pNext;//记录此元素列的最高处，以便之后的free
            for(int i = 0; i < level; i++){
                temp->pNext = t1[i].pNext;
                temp = temp->pDown;
                if (temp != NULL){
                    while (temp->pNext != NULL &&temp->pNext->dat != value){
                        temp = temp->pNext;
                    }
                    if (temp->pNext == NULL){
                        free(t1);
                        cout << "Delete value: " << value << " successfully!" << endl;
                        return;
                    }
                }
                else{
                    free(t1);
                    cout << "Delete value: " << value << " successfully!" << endl;
                    return;
                }

            }
        }
        else{
            temp = temp->pDown;
        }
    }
    cout << "value " << value << " not found," << " Delete failed!"<<endl;
}

搜索跳表中的元素：

void skipList::search(int value){
    NODE * temp = pSkipL;
    while (temp != NULL){
        while (temp->pNext != NULL && value > temp->pNext->dat){
            temp = temp->pNext;
        }
        if (temp->pNext != NULL&&temp->pNext->dat == value){
            cout << "Found value: " << temp->pNext->dat << endl;
            return;
        }
        else{
            temp = temp->pDown;
        }
    }
    cout << "value " << value << " not found!" << endl;
}

随机产生层数：

int skipList::random(){
    int level = 1;  
    while (rand() % 2 == 1 && level < MAX_LEVEL){//几何分布，期望是2层
        level++;
    }
    return level;
}

测试样例

#pragma once
 #include"skipChart.h"

 int main(){
    skipList l;
    int arr[5] = {1, 3, 5, 7, 9};
    int s = sizeof(arr) / sizeof(int);
    l.buildSkipList(arr,s);
    l.insert(4);
    l.insert(10);
    l.insert(6);

    l.search(1);
    l.delElement(1);
    l.search(1);
    l.search(3);
    l.delElement(3);
    l.search(3);
    l.search(6);
    l.delElement(6);
    l.search(6);
    l.delElement(-1);
    system("pause");    
    return 0;
 }

关于跳表，我刚刚学习的时候有个疑问，就是既然层数是随机的，那么怎么保证调表增删改查的时间复杂度呢？

原来跳表的时间复杂度不是固定的，但是在概率上是确定的，也就是有一个期望的时间复杂度。

其实跳表顺时针旋转90度就像一个多叉树，层数就是叉数，所以层数的期望值x就是查找的时间复杂度的对数底：即时间复杂度是O（logxN）.
这里有一篇博客讲的比较清楚：http://m.blog.csdn.net/article/details?id=38706729

我这里实现的跳表比较麻烦，浪费了很多空间，这两天应该会抽时间优化，用指针数组取代真实的层数模拟，从而节省空间。