leveldb(五)：SkipList跳表

跳表原理的简单介绍

跳表是平衡树的一种替代的数据结构，但是和红黑树不相同的是，跳表对于树的平衡的实现是基于一种随机化的算法的，这样也就是说跳表的插入和删除的工作是比较简单的。

下面来研究一下跳表的核心思想：

先从链表开始，如果是一个简单的链表，那么我们知道在链表中查找一个元素I的话，需要将整个链表遍历一次。
如果是说链表是排序的，并且节点中还存储了指向前面第二个节点的指针的话，那么在查找一个节点时，仅仅需要遍历N/2个节点即可。

跳表的核心思想，其实也是一种通过“空间来换取时间”的一个算法，通过在每个节点中增加了向前的指针，从而提升查找的效率。

跳表的数据存储模型

我们定义：

如果一个基点存在k个向前的指针的话，那么陈该节点是k层的节点。
一个跳表的层MaxLevel义为跳表中所有节点中最大的层数。
下面给出一个完整的跳表的图示：

那么我们该如何将该数据结构使用二进制存储呢？通过上面的跳表的很容易设计这样的数据结构：

定义每个节点类型：

// 这里仅仅是一个指针
typedef struct nodeStructure *node;
typedef struct nodeStructure

{
keyType key; // key值
valueType value; // value值
// 向前指针数组，根据该节点层数的
// 不同指向不同大小的数组，指向的是不同层的后面节点
node forward[1];
};

我们在来看看leveldb中跳表节点的定义：

template<typename Key, class Comparator>struct SkipList<Key,Comparator>::Node {  explicit Node(const Key& k) : key(k) { }  Key const key;  Node* Next(int n) {    return reinterpret_cast<Node*>(next_[n].Acquire_Load());  }  void SetNext(int n, Node* x) {    next_[n].Release_Store(x);  }  Node* NoBarrier_Next(int n) {    return reinterpret_cast<Node*>(next_[n].NoBarrier_Load());  }  void NoBarrier_SetNext(int n, Node* x) {    next_[n].NoBarrier_Store(x);  } private:  port::AtomicPointer next_[1];}

总体上与我们上面所说的存储模型结构一样，只不过这里的next_用了AtomicPointer ，关于AtomicPointer 请参考前面写的博客，主要起到同步的作用。Next的函数是为了读取第n层的下一个节点，而SetNext则是设置第n层的下一个节点是谁。

再来看下leveldb跳表的定义：

class SkipList { private:  struct Node; private:  enum { kMaxHeight = 12 };//跳表最高多少层  Comparator const compare_;//比较节点key大小的  Arena* const arena_;    //为节点分配空间用的  Node* const head_;  //指向表头  // Modified only by Insert().  Read racily by readers, but stale  // values are ok.  port::AtomicPointer max_height_;   //目前跳表最高多少层  Random rnd_; //用来生成每个节点层数的随机数生成器  ...}

跳表的代码实现分析

template<typename Key, class Comparator>SkipList<Key,Comparator>::SkipList(Comparator cmp, Arena* arena)    : compare_(cmp),      arena_(arena),      head_(NewNode(0 , kMaxHeight)),//头部节点初始化为具有最高层数的节点      max_height_(reinterpret_cast<void*>(1)),//但当前跳表高度初始化为1，就是只有最下面一层      rnd_(0xdeadbeef) {  for (int i = 0; i < kMaxHeight; i++) {    head_->SetNext(i, NULL);  }}template<typename Key, class Comparator>typename SkipList<Key,Comparator>::Node*SkipList<Key,Comparator>::NewNode(const Key& key, int height) {  char* mem = arena_->AllocateAligned(      sizeof(Node) + sizeof(port::AtomicPointer) * (height - 1));  //这种分配方式很有特色  return new (mem) Node(key);}

插入操作

template<typename Key, class Comparator>void SkipList<Key,Comparator>::Insert(const Key& key) {  Node* prev[kMaxHeight];  //从最高层往下依次寻找各层大于或等于key的节点，并把各层前一个节点保存在prev中便于插入  Node* x = FindGreaterOrEqual(key, prev);  //随机生成几点层数，RandomHeight保证不会超过跳表规定的最高层kMaxHeight  int height = RandomHeight();  if (height > GetMaxHeight()) {  //把大于原来跳表高度的层的prev节点设为头，最后更新跳表高度    for (int i = GetMaxHeight(); i < height; i++) {      prev[i] = head_;    }    max_height_.NoBarrier_Store(reinterpret_cast<void*>(height));  }  x = NewNode(key, height);  for (int i = 0; i < height; i++) {    // NoBarrier_SetNext() suffices since we will add a barrier when    // we publish a pointer to "x" in prev[i].    //更新各层，将新节点插入    x->NoBarrier_SetNext(i, prev[i]->NoBarrier_Next(i));    //这里使用了内存屏障，保证了下面这条setnext一定在上面那个setnext后发生，    //想想如果后面这个先发生会发生什么，先将prev的下一个节点设为了newNode，但    //newNode此时的next为null，无法继续读后面的节点，所以一定是先修改了newNode    //的next后在把newNode插入prev。    prev[i]->SetNext(i, x);  }  ｝

因为leveldb的跳表是作为memtable使用的，上层只有插入没有删除操作，因为上层的删除操作其实也就是插入操作而以，所以这里就不分析delete操作，其实原理与insert差不多。
其他操作也比较简单，就不分析了。

跳表的迭代器

class Iterator {   public:    explicit Iterator(const SkipList* list);    bool Valid() const;    const Key& key() const; //返回迭代器所处位置节点的值    void Next();    void Prev();    void Seek(const Key& target);    void SeekToFirst();//到跳表头    void SeekToLast();//到尾   private:    const SkipList* list_;//迭代器所迭代的跳表    Node* node_;//当前迭代器所处位置的节点  }

实现也比较简单，看名字就知道啥意思了。

template<typename Key, class Comparator>inline void SkipList<Key,Comparator>::Iterator::Seek(const Key& target) {  node_ = list_->FindGreaterOrEqual(target, NULL);}

seek就是在跳表中找到第一个key大于或等于target的元素。