Leveldb内部的Memtable其核心就是Skiplist，通过Skiplist来存放所有的数据，首先我们来看下Skiplist的结构，如下图:

通过上面的Skiplist结构可知，一个Skiplist是多个链表的集合，每一个链表都有一个header指针，指向这个链表，Leveldb中使用一个数组来存储所有的链表header.

struct SkipList<Key, Comparator>::Node {
  explicit Node(const Key& k) : key(k) {}

  Key const key;

  // Accessors/mutators for links.  Wrapped in methods so we can
  // add the appropriate barriers as necessary.
  Node* Next(int n) {
    assert(n >= 0);
    // Use an 'acquire load' so that we observe a fully initialized
    // version of the returned Node.
    return next_[n].load(std::memory_order_acquire);
  }
  void SetNext(int n, Node* x) {
    assert(n >= 0);
    // Use a 'release store' so that anybody who reads through this
    // pointer observes a fully initialized version of the inserted node.
    next_[n].store(x, std::memory_order_release);
  }

  // No-barrier variants that can be safely used in a few locations.
  Node* NoBarrier_Next(int n) {
    assert(n >= 0);
    return next_[n].load(std::memory_order_relaxed);
  }
  void NoBarrier_SetNext(int n, Node* x) {
    assert(n >= 0);
    next_[n].store(x, std::memory_order_relaxed);
  }

 private:
  // Array of length equal to the node height.  next_[0] is lowest level link.
  // 这是一个数组，使用了C/C++中的柔性数组的能力。
  std::atomic<Node*> next_[1];
};

typename SkipList<Key, Comparator>::Node* SkipList<Key, Comparator>::NewNode(
    const Key& key, int height) {
  // 根据指定的高度分配数组。
  char* const node_memory = arena_->AllocateAligned(
      sizeof(Node) + sizeof(std::atomic<Node*>) * (height - 1));
  return new (node_memory) Node(key);
}

这个链表数组中的第一个链表被称为Level0，通过这个链表可以遍历所有的数据，Levele1以及后面的链表则这是包含了部分数据。而且越大的level所包含的数据越少。这么做的目的是为了在查找的时候可以更快的找到数据的位置，接下来我们来看下整个查找过程是如何的.

1. 首先从最大的Level所对应的链表进行查找(上图中就是level3)
2. 在当前遍历链表找到第一个大于或者等于要查找的key的位置或者直接查找到结束(也就是元素6的位置，因为后面没有节点了)
3. 如果当前level没有查找到就继续切换到下一个level进行查找(切换到level2，继续查找，还是在当前位置，因为25大于17找到了，继续切换到level1，这个时候找到了9)
4. 直到在level0中找到这样的位置，并返回(找到了12，然后和17进行对比发现不相等。)

bool SkipList<Key, Comparator>::Contains(const Key& key) const {
  Node* x = FindGreaterOrEqual(key, nullptr);
  if (x != nullptr && Equal(key, x->key)) {
    return true;
  } else {
    return false;
  }
}

template <typename Key, class Comparator>
bool SkipList<Key, Comparator>::KeyIsAfterNode(const Key& key, Node* n) const {
  // null n is considered infinite
  return (n != nullptr) && (compare_(n->key, key) < 0);
}

// 总是返回第一个大于等于key的前一个节点。
template <typename Key, class Comparator>
typename SkipList<Key, Comparator>::Node*
SkipList<Key, Comparator>::FindGreaterOrEqual(const Key& key,
                                              Node** prev) const {
  Node* x = head_;
  // 1. 从最大的Level开始查找
  int level = GetMaxHeight() - 1;
  while (true) {
    // 2. 遍历链表，找到第一个大于等于key的节点。
    Node* next = x->Next(level);
    if (KeyIsAfterNode(key, next)) {
      // 没有大于等于key，并且还未遍历结束，继续在当前链表进行查找
      // Keep searching in this list
      x = next;
    } else {
      // 找到第一个大于等于key的节点或者当前level遍历结束了。
      if (prev != nullptr) prev[level] = x;
      // 如果是最后一层了，就直接返回
      if (level == 0) {
        return next;
      } else {
        // 切换到下一个level继续查找
        // Switch to next list
        level--;
      }
    }
  }
}

从上面的查找过程可以看到从高的level开始查找的目的是为了快速找到要查找的数据在level0的大概位置，有点类似二分查找。所有的数据都可以通过level0遍历到，高的level中只包含了level0中的部分数据。最后我们来看下如果插入数据来构建skiplist，插入过程如下图:

1. 首先找到大于等于要查找节点的前一个节点，并记录每一个level下找到的大于等于要查找数据的前一个节点。
2. 如果有相同的key就插入失败。
3. 随机获取一个高度，比如这里获取的高度是1
4. 构造新节点，并让level0指向新节点，然后找到随机获取的level所对应的前一个节点，然后指向这个新节点。

void SkipList<Key, Comparator>::Insert(const Key& key) {
  // TODO(opt): We can use a barrier-free variant of FindGreaterOrEqual()
  // here since Insert() is externally synchronized.
  Node* prev[kMaxHeight];
  Node* x = FindGreaterOrEqual(key, prev);

  // Our data structure does not allow duplicate insertion
  assert(x == nullptr || !Equal(key, x->key));

  int height = RandomHeight();
  // 如果大于当前的最大高度就进行扩展，从最大高度到获取的随机高度之间设置prev为header
  // 也就是在这个范围内，直接用header指针指向新创建的元素。
  if (height > GetMaxHeight()) {
    for (int i = GetMaxHeight(); i < height; i++) {
      prev[i] = head_;
    }
    // It is ok to mutate max_height_ without any synchronization
    // with concurrent readers.  A concurrent reader that observes
    // the new value of max_height_ will see either the old value of
    // new level pointers from head_ (nullptr), or a new value set in
    // the loop below.  In the former case the reader will
    // immediately drop to the next level since nullptr sorts after all
    // keys.  In the latter case the reader will use the new node.
    max_height_.store(height, std::memory_order_relaxed);
  }

  // 创建新的节点
  x = NewNode(key, height);
  // 从level0开始，插入到每一层。
  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));
    prev[i]->SetNext(i, x);
  }
}

通过上面的代码可以看到，核心点在于随机获取了一个高度，然后从level0开始到这个高度的每一层都会插入这个新节点。