C 语言项目怎么实现跳表 SkipList

跳表（SkipList）是一种可以用于替代平衡树的数据结构，它通过在标准链表的基础上添加多级索引来提高搜索效率。跳表的核心特性是快速查找、插入和删除操作、使用空间换取时间。在实现跳表时，我们通常需要定义节点含有多级指针的结构，根据提升概率来决定节点所跨越的层级，从而实现跳跃式的节点访问和数据的快速查找。

为了详细描述跳表的实现，以下内容将详细介绍跳表的结构定义、插入、查找、删除操作以及跳表的优缺点和应用场景。

一、跳表结构定义

跳表由含有多级指针的节点组成。每个节点提供了多个指向其他节点的指针，这些指针对应于不同的层级，其中0层是基础链表。跳表全部节点构成0层，节点通过随机过程决定其在高层出现的次数，即高层包含的是0层的子集。

创建节点结构

节点（SkListNode）通常包含了数据域和指向同级别下一个节点的指针（next）的数组，数组的大小取决于节点的层级。

typedef struct SkListNode {
    int key;
    int value;
    struct SkListNode *forward[]; // 指向不同层的下一个节点
} SkListNode;

定义跳表结构

跳表（SkipList）结构需要包含跳表节点，以及表示跳表当前层数和最大层数的变量。

typedef struct SkipList {
    int level;       // 当前跳表索引层数
    int maxLevel;    // 跳表的最大层数
    SkListNode *header; // 带有前向指针的头节点
} SkipList;

二、初始化跳表

为了使用跳表，首先需要初始化，创建一个带有头节点（header）的空跳表。

创建跳表

初始化跳表时，应创建一个头节点，并为其分配足够的层级指针，同时将每一层的指针设置为NULL。

SkipList* createSkipList(int maxLevel) {
    SkipList *sl = (SkipList*)malloc(sizeof(SkipList));
    sl->level = 0;
    sl->maxLevel = maxLevel;
    // 创建头节点，并为头节点分配 maxLevel+1 个指针
    SkListNode *header = (SkListNode*)malloc(sizeof(SkListNode) + sizeof(SkListNode*) * (maxLevel + 1));
    for(int i = 0; i <= maxLevel; i++) {
        header->forward[i] = NULL;
    }
    sl->header = header;
    return sl;
}

随机生成层级

在插入新节点时，需要随机决定节点存储到跳表的哪些层次上。

int randomLevel(int maxLevel) {
    int level = 1;
    while ((rand() & 0xFFFF) < (0.5 * 0xFFFF)) {
        level += 1;
    }
    return (level < maxLevel) ? level : maxLevel;
}

三、跳表插入操作

跳表的插入包括查找正确的插入位置、创建新节点以及调整指针以包含新节点。

查找插入位置

在向跳表插入一个新节点之前，需要从跳表的顶层索引开始向下寻找，直到找到合适的插入位置。

void insert(SkipList *sl, int key, int value) {
    SkListNode *update[sl->maxLevel + 1];
    SkListNode *x = sl->header;
    // 从最高层开始往下查找，记录每层的更新点
    for (int i = sl->level; i >= 0; i--) {
        while (x->forward[i] != NULL && x->forward[i]->key < key) {
            x = x->forward[i];
        }
        update[i] = x;
    }
    x = x->forward[0];

插入新节点

如果目标位置已有与插入键值相同的节点，则更新该节点的值。否则，创建新的节点并将其插入到跳表中。

    if (x == NULL || x->key != key) {
        int lvl = randomLevel(sl->maxLevel);
        if (lvl > sl->level) {
            for (int i = sl->level + 1; i <= lvl; i++) {
                update[i] = sl->header;
            }
            sl->level = lvl;
        }
        x = (SkListNode*)malloc(sizeof(SkListNode) + sizeof(SkListNode*) * (lvl + 1));
        x->key = key;
        x->value = value;
        for (int i = 0; i <= lvl; i++) {
            x->forward[i] = update[i]->forward[i];
            update[i]->forward[i] = x;
        }
    } else {
        x->value = value; // 更新值
    }
}

四、跳表查找操作

跳表的查找操作通过节点的层级指针从顶层开始寻找，如果当前指针指向的节点的键值小于查找键，则向前移动；如果大于，则移动到下一层继续查找。

实现查找操作

在查找操作中，我们遍历每个层级，直到找到第一个键值大于或等于目标键值的节点，然后转到下一层继续查找。如果找到节点并且节点的键值等于目标键值，则返回该节点。

SkListNode* search(SkipList *sl, int key) {
    SkListNode *x = sl->header;
    for (int i = sl->level; i >= 0; i--) {
        while (x->forward[i] != NULL && x->forward[i]->key < key) {
            x = x->forward[i];
        }
    }
    x = x->forward[0];
    if (x != NULL && x->key == key) {
        return x; // 找到节点，返回节点指针
    } else {
        return NULL; // 未找到节点，返回 NULL
    }
}

五、跳表删除操作

删除操作类似于插入操作，在查找到需要删除的节点后，逐层将其从跳表中移除，并调整相关指针。

实现删除操作

在每一层，如果找到目标键值的节点，则更新当前层的指针，跳过要删除的节点。

void delete(SkipList *sl, int key) {
    SkListNode *update[sl->maxLevel + 1];
    SkListNode *x = sl->header;
    // 查找目标节点的前驱节点
    for (int i = sl->level; i >= 0; i--) {
        while (x->forward[i] != NULL && x->forward[i]->key < key) {
            x = x->forward[i];
        }
        update[i] = x;
    }
    x = x->forward[0];
    // 如果找到，逐层删除
    if (x != NULL && x->key == key) {
        for (int i = 0; i <= sl->level; i++) {
            if (update[i]->forward[i] != x) break;
            update[i]->forward[i] = x->forward[i];
        }
        free(x);
        // 调整跳表高度
        while (sl->level > 0 && sl->header->forward[sl->level] == NULL) {
            sl->level--;
        }
    }
}