Redis学习笔记(二)----跳跃表

原 作者 杨龙飞 | 发表于 | 分类于 2014级

Skip List 介绍

Skip List是一种随机化的数据结构，基于并联的链表，其效率可比拟于二叉查找树（对于大多数操作需要O(log n)平均时间）。基本上，跳跃列表是对有序的链表增加上附加的前进链接，增加是以随机化的方式进行的，所以在列表中的查找可以快速的跳过部分列表(因此得名)。所有操作都以对数随机化的时间进行。Skip List可以很好解决有序链表查找特定值的困难。

Skip List的定义

1.一个跳表，应该具有以下特征：

  • 一个跳表应该有几个层（level）组成；
  • 跳表的第一层包含所有的元素；
  • 每一层都是一个有序的链表；
  • 如果元素x出现在第i层，则所有比i小的层都包含x；
  • 第i层的元素通过一个down指针指向下一层拥有相同值的元素；

Skip 的操作

2.构建有序链表

这里写图片描述

3.一个跳跃表如下:

这里写图片描述
我定义的跳跃表的数据结构

class SkipNode{


    //指针数组
    SkipNode<E> **forward;
     E data;
 };
class list_skip{
    int maxlevel;  //跳跃表允许的最大级数
    int levels;    //已存在的非空层数
    SkipNode<E>* head;  //跳跃表的头指针
    SkipNode<E>* tail; //跳跃表的尾指针
    E Tail_key;  //限定节点的值在一定的范围中.
};

4.查找

在跳跃表中查找一个元素x,按照如下几个步骤进行.
1.从最上层链的开头开始找.
2.假设当前位置为p,它向右指向节点q(p与q不一定相邻),且q的值为y,将y与x作比较

  • x=y 输出查询成功及相关信息
  • x>y 从p向右移动到q的位置

  • x < y 从p向下移动一格.

    1. 如果当前位置在最底层的链中(S0)，且还要往下移动的话,查询失败.

这里写图片描述

5.插入

首先明确，向跳跃表中插入一个元素，相当于在表中插入一列从S0中某一位置出发向上的连续一段元素。有两个参数需要确定，即插入列的位置以及它的“高度”。
关于插入的位置，我们先利用跳跃表的查找功能，找到比x小的最大的数y。根据跳跃表中所有链均是递增序列的原则，x必然就插在y的后面。
而插入列的“高度”较前者来说显得更加重要，也更加难以确定。由于它的不确定性，使得不同的决策可能会导致截然不同的算法效率。为了使插入数据之后，保持该数据结构进行各种操作均为O(logn)复杂度的性质，我们引入随机化算法（Randomized Algorithms）。

//产生一个随机级号<=maxlevel;
 template <class E>
 int list_skip<E>::Rlevel(){
     int level = 0;
     while(rand()%2){
        level++;
     }
     return (level <= maxlevel)?level:maxlevel;
 }

插入一个元素:

1.根据自己的随机算法,生成一个随机数,如果此数大于当前的已存在的非空层数,则层数加1.
2.从上层到下层,记录每层要插入的位置的前一个位置.
3.从上层到下层,依次更新指针的指向.
4.重复上面的步骤1,2,3;

6.删除

删除操作分为以下三个步骤：

在跳跃表中查找到这个元素的位置，如果未找到，则退出
将该元素所在整列从表中删除.
将多余的“空链”删除

这里写图片描述

完整代码:
Strorm_skiplist.h

#include <iostream>
#include <stdlib.h>
#include <math.h>

template<class E>
class SkipNode{
public:
    //构造函数
    //size 是根据节点的个数计算的最合适的层数.
    SkipNode(int size){
        forward = new SkipNode<E>*[size];
    }
    friend int operator < (SkipNode<E> t1,SkipNode<E> t2){
        if(t1.data < t2.data){
            return 1;
        }else{
            return 0;
        }
    }
    friend int operator > (SkipNode<E> t1,SkipNode<E> t2){
        if(t1.data > t2.data){
            return 1;
        }else{
            return 0;
        }
    }
    friend int operator == (SkipNode<E> t1,SkipNode<E> t2){
        if(t1.data == t2.data){
            return 1;
        }else{
            return 0;
        }
    }
    //成员函数
    void setData(E pData){
        data = pData;
    }
    ~SkipNode(){
        delete[] forward;
    }
    E getData(){
        return data;
    }

    //指针数组
    SkipNode<E> **forward;
private:
    E data;
};
template<class E>
class list_skip{
public:
    list_skip(E large,int MaxE = 10000,float p = 0.5); //构造函数
    list_skip()=default;
    ~list_skip();

    int Rlevel();
    int Insert(E Pvalue); //插入元素
    bool Delete(E Pvalue); //删除元素

    E Search(E Pvalue);  //查找指定的值

    void print();
private:
    int maxlevel;  //跳跃表允许的最大级数
    int levels;    //已存在的非空层数
    SkipNode<E>* head;  //跳跃表的头指针
    SkipNode<E>* tail; //跳跃表的尾指针
    E Tail_key;  //限定节点的值在一定的范围中.
};

StormDB_skiplist.cpp

#include "StormDB_skiplist.h"
#include<iostream>

/**
 *构造函数,large表示节点允许的最大值
 */
 template<class E>
 list_skip<E>::list_skip(E large,int MaxE,float p){
    Tail_key = large;
    maxlevel = ceil(log(MaxE)/log(1/p))-1;
    levels = 0;

    //创建头节点,尾节点.
    head = new SkipNode<E>(maxlevel+1);
    tail = new  SkipNode<E>(maxlevel+1);

    //让头节点的每个指针都先指在tail这块地方
    tail->setData(large);
     for(int i = 0; i <= maxlevel; ++i){
         head -> forward[i] = tail;
     }
 }
 //析构函数
 template<class E>
 list_skip<E>::~list_skip(){
     SkipNode<E> *next;
     //通过删除0级链的所有节点.
     while(head != tail){
         next = head->forward[0]; //forward[0]中是0级下一个元素的地址.
         delete head;
         head = next;
     }
     delete tail;
 }
 //产生一个随机级号<=maxlevel;
 template <class E>
 int list_skip<E>::Rlevel(){
     int level = 0;
     while(rand()%2){
        level++;
     }
     return (level <= maxlevel)?level:maxlevel;
 }
 //向跳跃表插入元素
 template<class E>
 int list_skip<E>::Insert(E pData){
     //值太大或者已经存在
     if(pData >= Tail_key || this -> Search(pData)){
         return 0;
     }
     //创建一个新的节点,并将其初始化
     SkipNode<E>* newNode = new SkipNode<E>(maxlevel+1);
     newNode->setData(pData);
     for(int i = 0;i <= maxlevel; ++i){
         newNode->forward[i] = tail;
     }
     //为新节点创建级号
     int leval = Rlevel();
     std::cout << "level = "<< leval <<" levels = "<< levels <<std::endl;

     //如果随机出来的层数大于已存在的非空层,则增加一层
     int key_level = ((leval >= levels)? levels : leval);
     if(leval > levels){
         ++levels;
    }

     //建立一个指针数组保存每层要插入数据的位置
     SkipNode<E>** update = new SkipNode<E>*[maxlevel];
     SkipNode<E>* p = head;
     SkipNode<E>* q = NULL;


     //从高往低查找处合适的位置然后插入
     for(int i = key_level; i >= 0;--i){
         while((q = p->forward[i]) != tail && q -> getData() < pData){
             p = q;
         }
         update[i] = p; //把新元素插入到p元素之后.
     }
     for(int i = key_level; i >= 0;--i){
         newNode->forward[i] = update[i]->forward[i];
         update[i]->forward[i] = newNode;
     }
     delete[] update;

 }
 //从跳跃表中删除指定的值
 template<class E>
 bool list_skip<E>::Delete(E pData){
     SkipNode<E>* p = head;
     SkipNode<E>* q = NULL;
     for(int i = levels; i >= 0;--i){
         while((q = p->forward[i]) != tail && q->getData() <= pData){
             if(q->getData() == pData){
                 for(int j = 0;j <= levels; ++j){
                     p->forward[j] = q->forward[j];
                 }
                 delete q;
                 return true;
             }
             p = q;
         }
     }
     return false;
 }
//在跳跃表中查找指定的值

template<class E>
E list_skip<E>::Search(E pData){
    SkipNode<E>* p = head;
    SkipNode<E>* q = NULL;
    for(int i = levels;i >= 0;--i){
        while((q = p->forward[i]) != tail && q->getData() <= pData){
            if(q->getData() == pData){
                return pData;
            }
            p = q;
        }
    }
    return 0;
}
//输出跳跃表的内容
template<class E>
void list_skip<E>::print(){
    SkipNode<E> * temp = NULL;
    for(int i = 0;i <= levels;++i){
        temp = head->forward[i];
        std::cout << "层数:####->:"<<i<<" ";
        while(temp != tail){
            std::cout  << temp->getData() << "->";
            temp = temp -> forward[i];      
        }
        std::cout << std::endl;
    }
}
/*int main(int argc,char *argv[])
{
    list_skip<long> temp(10000);
    for(long i = 0; i < 30;i++){
        temp.Insert(i);
    }
    temp.print();
    temp.Delete(5);
    temp.Delete(4);
    temp.print();
    long p = temp.Search(6);
    std::cout << p<<std::endl;
    long q = temp.Search(5);
    std::cout << q<<std::endl;
   return 0;
}*/