skiplist

一、跳表简介

　　跳表（Skiplist）是一个特殊的链表，相比一般的链表，有更高的查找效率，可比拟二叉查找树，平均期望的查找、插入、删除时间复杂度都是O(logn)，许多知名的开源软件（库）中的数据结构均采用了跳表这种数据结构。

• Redis中的有序集合zset
• LevelDB、RocksDB、HBase中Memtable
• ApacheLucene中的TermDictionary、Posting List

下面记录一个跳表实现：

#include "list.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define SKIPLIST_MAXLEVEL 32 /* Should be enough for 2^32 elements */
#define SKIPLIST_P 0.25      /* Skiplist P = 1/4 */

typedef struct skiplist
{
    int              level;
    int              count;
    struct list_head head[SKIPLIST_MAXLEVEL];
} skipList;

typedef struct skipnode
{
    int              key;
    int              value;
    struct list_head forward[0];
} skipNode;

#define skiplist_foreach(pos, end) 
        for (; pos != end; pos = pos->next)

#define skiplist_foreach_safe(pos, n, end) 
        for (n = pos->next; pos != end; pos = n, n = pos->next)

static int find_count = 0;

skipNode* skipnode_new(int level, int key, int value)
{
    skipNode* node = NULL;

    node = malloc(sizeof(skipNode) + level * sizeof(skipList));
    if (NULL == node) {
        return NULL;
    }
    node->key   = key;
    node->value = value;

    return node;
}

void skipnode_delete(skipNode* node)
{
    if (node) {
        free(node);
        node = NULL;
    }
}

skipList* skiplist_new(void)
{
    int       i    = 0;
    skipList* list = NULL;

    list = malloc(sizeof(skipList));
    if (NULL == list) {
        return NULL;
    }

    list->level = 1;
    list->count = 0;
    for (i = 0; i < SKIPLIST_MAXLEVEL; i++) {
        INIT_LIST_HEAD(&list->head[i]);
    }
    return list;
}

void skiplist_destory(skipList* list)
{
    struct list_head* start = NULL;
    struct list_head* n     = NULL;
    skipNode*         pNode = NULL;

    if (list) {
        start = list->head[0].next;

        skiplist_foreach_safe(start, n, &list->head[0])
        {
            pNode = list_entry(start, skipNode, forward[0]);
            skipnode_delete(pNode);
        }
        free(list);
        list = NULL;
    }
}

int random_level(void)
{
    int level = 1;
    while ((random() & 0xFFFF) < (SKIPLIST_P * 0xFFFF)) {
        level += 1;
    }

    return (level < SKIPLIST_MAXLEVEL) ? level : SKIPLIST_MAXLEVEL;
}

skipNode* skiplist_search(skipList* list, int key)
{
    struct list_head* start = NULL;
    struct list_head* end   = NULL;
    skipNode*         pNode = NULL;
    int               i     = 0;

    if (NULL == list) {
        return NULL;
    }

    i     = list->level - 1;
    start = &list->head[i];
    end   = &list->head[i];
    for (; i >= 0; i--) {
        start = start->next;
        skiplist_foreach(start, end)
        {
            find_count++;
            pNode = list_entry(start, skipNode, forward[i]);
            if (pNode->key >= key) {
                end = &pNode->forward[i];
                break;
            }
        }
        if (pNode->key == key) {
            return pNode;
        }
        start = end->prev;
        start--;
        end--;
    }
    return NULL;
}

skipNode* skiplist_insert(skipList* list, int key, int value)
{
    int               i       = 0;
    int               level   = 0;
    skipNode*         newNode = NULL;
    skipNode*         pNode   = NULL;
    struct list_head* start   = NULL;
    struct list_head* end     = NULL;

    if (NULL == list) {
        return NULL;
    }

    level = random_level();
    if (level > list->level) {
        list->level = level;
    }

    newNode = skipnode_new(level, key, value);
    if (NULL == newNode) {
        return NULL;
    }

    i     = list->level - 1;
    start = &list->head[i];
    end   = &list->head[i];
    for (; i >= 0; i--) {
        start = start->next;
        skiplist_foreach(start, end)
        {
            pNode = list_entry(start, skipNode, forward[i]);
            if (pNode->key >= key) {
                end = &pNode->forward[i];
                break;
            }
        }
        start = end->prev;
        if (i < level) {
            list_add_tail(&newNode->forward[i], end);
        }
        end--;
        start--;
    }
    list->count++;

    return newNode;
}

static void _remove(skipList* list, skipNode* node, int level)
{
    int i = 0;
    for (i = 0; i < level; i++) {
        list_del(&node->forward[i]);
        if (list_empty(&list->head[i])) {
            list->level--;
        }
    }
    skipnode_delete(node);
    list->count--;
}

void skiplist_remove(skipList* list, int key)
{
    int               i     = 0;
    struct list_head* start = NULL;
    struct list_head* end   = NULL;
    struct list_head* n     = NULL;
    skipNode*         pNode = NULL;

    if (NULL == list) {
        return;
    }

    i     = list->level - 1;
    start = &list->head[i];
    end   = &list->head[i];
    for (; i >= 0; i--) {
        start = start->next;
        skiplist_foreach_safe(start, n, end)
        {
            pNode = list_entry(start, skipNode, forward[i]);
            if (pNode->key > key) {
                end = &pNode->forward[i];
                break;
            }
            else if (pNode->key == key) {
                _remove(list, pNode, i + 1);
            }
        }
        start = end->prev;
        start--;
        end--;
    }
}

void skiplist_dump(skipList* list)
{
    int               i     = 0;
    struct list_head* start = NULL;
    struct list_head* end   = NULL;
    skipNode*         pNode = NULL;

    if (NULL == list) {
        return;
    }

    i     = list->level - 1;
    start = &list->head[i];
    end   = &list->head[i];
    for (; i >= 0; i--) {
        start = start->next;
        skiplist_foreach(start, end)
        {
            pNode = list_entry(start, skipNode, forward[i]);
            printf("%5d ", pNode->key);
        }
        start = &list->head[i];
        start--;
        end--;
        printf("
");
    }
}

int main(int argc, char** argv)
{
    int       i        = 0;
    skipList* skiplist = NULL;
    skipNode* pNode    = NULL;
    int       key      = 0;

    skiplist = skiplist_new();
    if (NULL == skiplist) {
        printf("skiplist is null");
        return -1;
    }

    for (i = 0; i < 10000; i++) {
        skiplist_insert(skiplist, i, i);
    }

    key   = 5000;
    pNode = skiplist_search(skiplist, key);
    if (pNode) {
        printf("key: %d found, find times: %d
", key, find_count);
    }
    else {
        printf("key:%d, not found
", key);
    }

    key   = 9999;
    pNode = skiplist_search(skiplist, key);
    if (pNode) {
        printf("key: %d found, find times: %d
", key, find_count);
    }
    else {
        printf("key:%d, not found
", key);
    }

    skiplist_destory(skiplist);

    return 0;
}

可以看出，跳表在查找、插入、删除时性能更好

/*
[zhangwj@xxx skiplist]$ ./a.out 
key: 5000 found, find times: 20
key: 9999 found, find times: 31
[zhangwj@xxx skiplist]$ 
*/