实现跳表

#include <stdio.h>
#include <stdlib.h>
#define CASE_NUM 20000
#define LEVEL 10

struct Node 
{
    int value;
    int level;
    struct Node* down_p;
    struct Node* next;
};

struct Node* init_skip_list(int level)
{
    int i;

    struct Node* NodeList[level];
    for(i=0; i<level; ++i)
    {
        NodeList[i] = (struct Node*)malloc(sizeof(struct Node));
        NodeList[i]->next = NULL;
        NodeList[i]->value = 0;
        NodeList[i]->level = i+1;
        if(i>0)
        {
            NodeList[i]->down_p = NodeList[i-1];
            printf("build down forward, level=%d
", i+1);
        } 
        else 
        {
            NodeList[i]->down_p = NULL;
        }
    }
    return NodeList[level-1];
}

int get_rand_level(int level)
{
    int value_level = 1;
    while(rand()%2) value_level ++;
    if(value_level > level) value_level = level;
    return value_level;
}

int insert_number(int value, struct Node* node, int level)
{
    int value_level;
    int i;
    int cost_step = 0;
    value_level = get_rand_level(level);

    struct Node* NodeList[level];
    int level_run[level];

    for(i=0; i<level; ++i) level_run[i] = 0;

    struct Node* tmp; // temp storage node
    tmp = NULL;
    int insert = 0;
    while(node != NULL)
    {
        insert = node->level <= value_level ? 1 : 0;

        struct Node* new_node;
        new_node = (struct Node*)malloc(sizeof(struct Node));
        new_node->value = value;
        new_node->level = node->level;
        new_node->down_p = NULL;

        while(1)
        {
            if(node->next && node->next->value < value)
            {
                node = node->next;
                cost_step ++;
                level_run[node->level-1] ++;
            } 
            else
            {
                if(insert)
                {
                    new_node->next = node->next;
                    node->next = new_node;
                    if(tmp != NULL)
                    {
                        tmp->down_p = new_node;
                    }
                    tmp = new_node;
                }
                /*
                else
                {
                    printf("Now level is %d, need create under %d level
",
                            node->level, value_level);
                }
                */
                //printf("Success insert new node, value=%d, level=%d
",
                //        value, i+1);
                break;
            }
        }
        node = node->down_p;
    }
    /* DEBUG PIRNT
    printf("---- value %d cost step ----
", value);
    for(i=0; i<level; ++i)
    {
        printf("level %d cost step %d
", i+1, level_run[i]);
    }
    */
    return cost_step;
}

int find_number(int value, struct Node* node)
{
    int i;
    int find = 0;
    int cost_step = 0;
    while(node != NULL)
    {
        //printf("node->value=%d, node->level=%d, node->down_p=%p, node->next=%p
", 
        //        node->value, node->level, node->down_p, node->next);
        while(node->next && node->next->value<=value)
        {
            //printf("step forward one step
");
            node = node->next;
            cost_step ++;
        }
        if(node->value == value)
        {
            find = 1;
            break;
        }
        //printf("node->down_p->value=%d, node->down_p->level=%d, node->down_p->down_p=%p
",
        //        node->down_p->value, node->down_p->level, node->down_p->down_p);
        node = node->down_p;
        cost_step ++;
    }
    //printf("find %d cost step %d
", value, cost_step);
    if(find!=1)
    {
        printf("Warning, error occured, value=%d
", value);
    }
    return cost_step;
}

void show_skip_list(struct Node* node, int level)
{
    int i;
    struct Node* NodeList[level];
    struct Node* p;
    int NodeCnt[level];
    for(i=0; i<level; ++i)
    {
        NodeList[level-i-1] = node;
        node = node->down_p;
        NodeCnt[i] = 0;
    }

    for(i=level-1; i>=0; --i)
    {
        int sign = 0;
        p = NodeList[i];
        while(p)
        {
            /*
            if(sign)
            {
                printf(" -> %d", p->value);
            }
            else
            {
                printf("%d", p->value);
            }
            */
            sign = 1;
            NodeCnt[i] ++;
            p = p->next;
        }
        //printf("
");
    }
    for(i=0; i<level; ++i) printf("level %d cnt %d
", i+1, NodeCnt[i]);
    return;
}

int main()
{
    int level = LEVEL;
    int res;
    int i;
    int tmp;
    struct Node* p;
    p = init_skip_list(level);

    int test_data[CASE_NUM];
    long long total_insert_cost_step = 0;
    int one_time;
    
    for(i=0; i<CASE_NUM; i++)
    {
        tmp = rand()%1000000;
        test_data[i] = tmp;
        one_time = insert_number(tmp, p, level);
        total_insert_cost_step += one_time;
        //printf("inserting %d cost %d step
", tmp, one_time);
    }
    printf("insert average cost %lld step
", total_insert_cost_step/CASE_NUM);
    printf("Begin show_skip_list
");
    show_skip_list(p, level);
    int total_cost_step = 0;
    for(i=0;i<CASE_NUM;i++)
    {
        tmp = test_data[i];
        res = find_number(tmp, p);
        total_cost_step += res;
    }
    printf("Average cost %d step
", total_cost_step/CASE_NUM);
    return 0;
}

自己手写了一下跳表，加深了对跳表的理解，贴一下代码

输出

insert average cost 21 step
Begin show_skip_list
level 1 cnt 20001
level 2 cnt 10031
level 3 cnt 5087
level 4 cnt 2567
level 5 cnt 1333
level 6 cnt 704
level 7 cnt 367
level 8 cnt 191
level 9 cnt 95
level 10 cnt 51
Average cost 40 step

相比较之下，python的heapq插入速度明显比我实现的这个跳表快很多，这点我需要研究一下。看看为啥我这个这么慢