跳表（skiplist）的代码实现

跳表（skiplist）是一个非常优秀的数据结构，实现简单，插入、删除、查找的复杂度均为O(logN)。LevelDB的核心数据结构是用跳表实现的，redis的sorted set数据结构也是有跳表实现的。

其结构如下所示：

所有操作均从上向下逐层查找，越上层一次next操作跨度越大。其实现是典型的空间换时间。

具体的细节，可参考维基百科 http://en.wikipedia.org/wiki/Skip_list

 

本文作者将redis的sorted set代码进行整理，将跳表部分的实现抽取出来，供参考。

skiplist.h

#ifndef __SKIPLIST_H
#define __SKIPLIST_H
    
#define SKIPLIST_MAXLEVEL 8    
    
typedef struct skiplistNode {
         double score;
         struct skiplistNode *backward;
         struct skiplistLevel {
                 struct skiplistNode *forward;
         }level[];
}skiplistNode;
    
typedef struct skiplist {
         struct skiplistNode *header, *tail;
         unsigned long length;
         int level;
}skiplist;
    
#endif

skiplist.c

#include "skiplist.h"
#include <stdlib.h>
#include <stdio.h>
    
skiplistNode *slCreateNode( int level, double score) {
         skiplistNode * sn = malloc( sizeof(*sn) + level* sizeof( struct skiplistLevel));
         sn->score = score;
         return sn;
}
    
skiplist *slCreate( void) {
         int j;
         skiplist *sl;
    
         sl = malloc( sizeof(*sl));
         sl->level = 1;
         sl->length = 0;
         sl->header = slCreateNode(SKIPLIST_MAXLEVEL, 0);
         for(j = 0; j < SKIPLIST_MAXLEVEL; j++) {
                 sl->header->level[j].forward = NULL;
         }
         sl->header->backward = NULL;
         sl->tail = NULL;
         return sl;
}
    
void slFreeNode(skiplistNode *sn) {
         free(sn);
}
    
void slFree(skiplist *sl) {
         skiplistNode *node = sl->header->level[0].forward, *next;
    
         free(sl->header);
         while(node) {
                 next = node->level[0].forward;
                 slFreeNode(node);
                 node = next;
         }
         free(sl);
}
    
int slRandomLevel( void) {
         int level = 1;
         while((rand()&0xFFFF) < (0.5 * 0xFFFF))    
                 level += 1;
         return (level < SKIPLIST_MAXLEVEL) ? level : SKIPLIST_MAXLEVEL;
}
    
skiplistNode *slInsert(skiplist *sl, double score) {
         skiplistNode *update[SKIPLIST_MAXLEVEL];
         skiplistNode *node;
    
         node = sl->header;
         int i, level;
         for ( i = sl->level-1; i >= 0; i--) {
                 while(node->level[i].forward && node->level[i].forward->score < score) {
                         node = node->level[i].forward;
                 }
                 update[i] = node;
         }
         level = slRandomLevel();
         if (level > sl->level) {
                 for (i = sl->level; i< level ;i++) {
                         update[i] = sl->header;
                 }
                 sl->level = level;
         }
         node = slCreateNode(level, score);
         for (i = 0; i < level; i++) {
                 node->level[i].forward = update[i]->level[i].forward;
                 update[i]->level[i].forward = node;
         }
    
         node->backward = (update[0] == sl->header? NULL : update[0]);
         if (node->level[0].forward)
                 node->level[0].forward->backward = node;
         else
                 sl->tail = node;
         sl->length++;
         return node;
}
    
void slDeleteNode(skiplist *sl, skiplistNode *x, skiplistNode **update){
         int i;
         for (i = 0; i < sl->level; i++) {
                 if (update[i]->level[i].forward == x) {
                         update[i]->level[i].forward = x->level[i].forward;
                 }
         }
         if (x->level[0].forward) {
                 x->level[0].forward->backward = x->backward;
         } else {
                 sl->tail = x->backward;
         }
         while (sl->level > 1 && sl->header->level[sl->level-1].forward == NULL)    
                 sl->level--;
         sl->length--;
}
    
int slDelete(skiplist *sl, double score) {
         skiplistNode *update[SKIPLIST_MAXLEVEL], *node;
         int i;
    
         node = sl->header;
         for(i = sl->level-1; i >= 0; i--) {
                 while (node->level[i].forward && node->level[i].forward->score < score) {
                         node = node->level[i].forward;
                 }
                 update[i] = node;
         }
         node = node->level[0].forward;
         if (node && score == node->score) {
                 slDeleteNode(sl, node, update);
                 slFreeNode(node);
                 return 1;
         } else {
                 return 0;
         }
         return 0;
}
    
int slSearch(skiplist *sl, double score) {
         skiplistNode *node;
         int i;
    
         node = sl->header;
         for (i = sl->level-1; i >= 0 ;i--) {
                 while(node->level[i].forward && node->level[i].forward->score < score) {
                         node = node->level[i].forward;
                 }
         }
         node = node->level[0].forward;
         if (node && score == node->score) {
                 printf( "Found %d\n",( int)node->score);
                 return 1;
         } else {
                 printf( "Not found %d\n", ( int)score);
                 return 0;
         }
}
    
void slPrint(skiplist *sl) {
         skiplistNode *node;
         int i;
         for (i = 0; i < SKIPLIST_MAXLEVEL; i++) {
                 printf( "LEVEL[%d]: ", i);
                 node = sl->header->level[i].forward;
                 while(node) {
                         printf( "%d -> ", ( int)(node->score));
                         node = node->level[i].forward;
                 }
                 printf( "NULL\n");
         }
}
    
#ifdef SKIP_LIST_TEST_MAIN
int main() {
         srand((unsigned)time(0));
         int count = 20, i;
    
         printf( "### Function Test ###\n");
    
         printf( "=== Init Skip List ===\n");
         skiplist * sl = slCreate();
         for ( i = 0; i < count; i++) {
                 slInsert(sl,i);
         }
         printf( "=== Print Skip List ===\n");
         slPrint(sl);
    
         printf( "=== Search Skip List ===\n");
         for (i = 0; i < count; i++) {
                 int value = rand()%(count+10);
                 slSearch(sl, value);
         }
         printf( "=== Delete Skip List ===\n");
         for (i = 0; i < count+10; i+=2) {
                 printf( "Delete[%d]: %s\n", i, slDelete(sl, i)? "SUCCESS": "NOT FOUND");
         }
         slPrint(sl);
    
         slFree(sl);
         sl = NULL;
}
#endif

测试结果如下所示：

### Function Test ###
=== Init Skip List ===
=== Print Skip List ===
LEVEL[0]: 0 -> 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8 -> 9 -> 10 -> 11 -> 12 -> 13 -> 14 -> 15 -> 16 -> 17 -> 18 -> 19 -> NULL
LEVEL[1]: 0 -> 2 -> 4 -> 7 -> 9 -> 10 -> 11 -> 12 -> 14 -> 15 -> 17 -> 18 -> NULL
LEVEL[2]: 7 -> 10 -> 12 -> 14 -> 15 -> NULL
LEVEL[3]: 10 -> 14 -> 15 -> NULL
LEVEL[4]: 10 -> 14 -> NULL
LEVEL[5]: NULL
LEVEL[6]: NULL
LEVEL[7]: NULL
=== Search Skip List ===
Found 1
Found 18
Not found 21
Not found 24
Found 10
Not found 20
Found 14
Found 10
Found 19
Found 18
Not found 27
Found 5
Found 0
Found 0
Found 18
Not found 26
Found 13
Not found 28
Not found 29
Not found 23
=== Delete Skip List ===
Delete[0]: SUCCESS
Delete[2]: SUCCESS
Delete[4]: SUCCESS
Delete[6]: SUCCESS
Delete[8]: SUCCESS
Delete[10]: SUCCESS
Delete[12]: SUCCESS
Delete[14]: SUCCESS
Delete[16]: SUCCESS
Delete[18]: SUCCESS
Delete[20]: NOT FOUND
Delete[22]: NOT FOUND
Delete[24]: NOT FOUND
Delete[26]: NOT FOUND
Delete[28]: NOT FOUND
LEVEL[0]: 1 -> 3 -> 5 -> 7 -> 9 -> 11 -> 13 -> 15 -> 17 -> 19 -> NULL
LEVEL[1]: 7 -> 9 -> 11 -> 15 -> 17 -> NULL
LEVEL[2]: 7 -> 15 -> NULL
LEVEL[3]: 15 -> NULL
LEVEL[4]: NULL
LEVEL[5]: NULL
LEVEL[6]: NULL
LEVEL[7]: NULL