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. 完结撒花
感谢观看