简单跳表-C语言

1.跳表的概念

跳表是一种数据结构，它是一种随机化的数据结构，通过具有多层的链表来加速查找的过程。跳表在有序链表基础上，增加了多层索引，使得查找可以跳跃式进行，从而提高了查找效率。

更简单化图解 ↓

2. 跳表实验

2.1构建跳表节点

这里构建的跳表的节点跟动态链表很像，存入键值，然后指向同一层级的下一指针。

// 跳表节点结构
typedef struct Node {
    int key; // 节点的键值
    struct Node *forward[]; // 指向同一层级的下一指针（可以有多个地址） 
} Node;

2.2 构建跳表的结构

这里主要是包含跳表的层数和头节点，这样子比较好分配新的一层的跳表

// 跳表结构
typedef struct SkipList {
    int level; // 跳表的层数
    struct Node *header; // 头节点
} SkipList;

2.3 创建一个新的节点

在同一层级上分配内存，然后给键值赋值。

// 创建一个新的节点
Node *createNode(int key, int level) {
    Node *node = (Node *)malloc(sizeof(Node) + level * sizeof(Node *));
    node->key = key;
    return node;
}

2.4 创建一个新的跳表

定义头节点（看跳跃表的图解所知）头节点是每一层都有的。要分配内存，然后给头节点初始化。

// 创建一个新的跳表
SkipList *createSkipList() {
    SkipList *list = (SkipList *)malloc(sizeof(SkipList));
    list->level = 0; // 初始化层数为 0
    Node *header = createNode(INT_MIN, MAX_LEVEL); // 创建头节点，键值为 INT_MIN
    list->header = header;
    for (int i = 0; i < MAX_LEVEL; i++) {
        header->forward[i] = NULL; // 初始化头节点的正向指针为 NULL
    }
    return list;
}

2.5 产生随机层数

在跳表中，所产生的多层是通过随机数而产生的层数，所以要定义一个随机数来分配随机层数。

// 创建一个新的跳表
SkipList *createSkipList() {
    SkipList *list = (SkipList *)malloc(sizeof(SkipList));
    list->level = 0; // 初始化层数为 0
    Node *header = createNode(INT_MIN, MAX_LEVEL); // 创建头节点，键值为 INT_MIN
    list->header = header;
    for (int i = 0; i < MAX_LEVEL; i++) {
        header->forward[i] = NULL; // 初始化头节点的正向指针为 NULL
    }
    return list;
}

2.6 向跳表中插入新的元素（重点）

插入节点的具体步骤：找到插入位置，创建新节点，更新指针，更新跳表的层数。这样，就完成了向跳表中插入新元素的过程。

// 向跳表中插入新的元素
void insertElement(SkipList *list, int key) {
    Node *update[MAX_LEVEL]; // 辅助数组用于存储每层需要更新的节点
    Node *current = list->header; // 从头节点开始查找
    for (int i = list->level - 1; i >= 0; i--) { // 从高层向底层搜索每层
        while (current->forward[i] != NULL && current->forward[i]->key < key) {
            current = current->forward[i]; // 如果当前层存在下一个节点且下一个节点的 key 小于要插入的 key，则继续向右前进
        }
        update[i] = current; // 记录当前层需要插入节点的前一个节点
    }
    current = current->forward[0]; // 将游标移动到最底层的下一个节点，准备执行插入操作
    if (current == NULL || current->key != key) {
        int newLevel = randomLevel(); // 随机生成新节点的层数
        if (newLevel > list->level) {
            for (int i = list->level; i < newLevel; i++) {
                update[i] = list->header; // 更新辅助数组中新增层数的位置
            }
            list->level = newLevel; // 更新跳表的层数
        }
        Node *newNode = createNode(key, newLevel); // 创建新节点
        for (int i = 0; i < newLevel; i++) {
            newNode->forward[i] = update[i]->forward[i]; // 更新新节点的指针
            update[i]->forward[i] = newNode; // 更新前一个节点的指针，将它指向新节点
        }
    }
}

以上其实就能构成一个简单的跳表了

3.简单跳表程序

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define MAX_LEVEL 6 // 定义跳表的最大层数

//跟链式结构很像，不过这个跳表是有多个层级 

// 跳表节点结构
typedef struct Node {
    int key; // 节点的键值
    struct Node *forward[]; // 指向同一层级的下一指针（可以有多个地址） 
} Node;

// 跳表结构
typedef struct SkipList {
    int level; // 跳表的层数
    struct Node *header; // 头节点
} SkipList;

// 创建一个新的节点
Node *createNode(int key, int level) {
    Node *node = (Node *)malloc(sizeof(Node) + level * sizeof(Node *));
    node->key = key;
    return node;
}

// 创建一个新的跳表
SkipList *createSkipList() {
    SkipList *list = (SkipList *)malloc(sizeof(SkipList));
    list->level = 0; // 初始化层数为 0
    Node *header = createNode(INT_MIN, MAX_LEVEL); // 创建头节点，键值为 INT_MIN
    list->header = header;
    for (int i = 0; i < MAX_LEVEL; i++) {
        header->forward[i] = NULL; // 初始化头节点的正向指针为 NULL
    }
    return list;
}

// 产生一个随机层数
int randomLevel() {
    int level = 1;
    while ((rand() % 2) == 0 && level < MAX_LEVEL) {// 决定节点的层数，可以有效地将节点分布在不同的层级上，从而提高跳表的效率。 
        level++;
    }
    return level;
}

// 向跳表中插入新的元素
void insertElement(SkipList *list, int key) {
    Node *update[MAX_LEVEL]; // 辅助数组用于存储每层需要更新的节点
    Node *current = list->header; // 从头节点开始查找
    for (int i = list->level - 1; i >= 0; i--) { // 从高层向底层搜索每层
        while (current->forward[i] != NULL && current->forward[i]->key < key) {//如果当前层存在下一个节点且下一个节点的 key 小于要插入的 key
            current = current->forward[i]; // 则继续向右前进
        }
        update[i] = current; // 记录当前层需要插入节点的前一个节点
    }
    current = current->forward[0]; // 将游标移动到最底层的下一个节点，准备执行插入操作
    if (current == NULL || current->key != key) {
        int newLevel = randomLevel(); // 随机生成新节点的层数
        if (newLevel > list->level) {
            for (int i = list->level; i < newLevel; i++) {
                update[i] = list->header; // 更新辅助数组中新增层数的位置
            }
            list->level = newLevel; // 更新跳表的层数
        }
        Node *newNode = createNode(key, newLevel); // 创建新节点
        for (int i = 0; i < newLevel; i++) {
            newNode->forward[i] = update[i]->forward[i]; // 更新新节点的指针
            update[i]->forward[i] = newNode; // 更新前一个节点的指针，将它指向新节点
        }
    }
}

// 打印跳表
void printSkipList(SkipList *list) {
    printf("跳表\n");
    for (int i = list->level - 1; i >= 0; i--) { // 从最高层向底层逐层打印节点的 key 值
        Node *node = list->header->forward[i];
        printf("第 %d 层：", i);
        while (node != NULL) {
            printf("%d ", node->key);
            node = node->forward[i];
        }
        printf("\n");
    }
}

int main() {
    srand((unsigned)time(NULL)); // 用当前时间设置随机种子
    
    SkipList *skipList = createSkipList(); // 创建一个新的跳表
    int element[]={3,6,7,9,12,17,19,21,25,26,34,40,45,48,32,19,23,54};  // 创建要插入的元素的数组
    int n = sizeof(element)/sizeof(int);  // 数组个数
    for (int i=0; i<n; i++)
        insertElement(skipList, element[i]); // 向跳表中插入若干元素
    printSkipList(skipList); // 打印跳表

    getchar();
    return 0;
}

在我看来就是动态链表的结合。

具有随机的多层。

4. 完结撒花

感谢观看