跳表实现（C语言）

最新推荐文章于 2025-02-18 17:04:56 发布
原创 最新推荐文章于 2025-02-18 17:04:56 发布 · 413 阅读 · 5 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构

以下是关于跳表（Skip List）的详细介绍，包括概念、原理、用途以及使用C语言实现的代码示例（带有注释）：

概念

跳表是一种有序的数据结构，它通过在原始的有序链表基础上，增加多级索引来提升查找、插入和删除等操作的效率，其在功能上可以类比平衡二叉树（如红黑树等），但实现相对更简单直观。

原理

• 跳表基于概率构建多级索引。最底层是一个完整的有序链表，存储了所有的元素。然后在这个链表之上，每隔几个节点（这个间隔通常按照一定概率确定，比如随机决定一个节点是否提升为上一级索引节点）就抽出一些节点组成上一级索引链表，依次类推构建多级索引链表。

• 在查找元素时，就可以先从最顶层的索引链表开始查找，快速定位到大致范围后，再逐步下到下一级索引链表或者底层链表进行更精细的查找，通过这种“跳跃”式的查找方式，减少了比较次数，提高了查找效率。

• 插入和删除操作除了要对原始链表进行相应操作外，还需要根据概率去维护各级索引链表，保证索引结构的正确性。

用途

• 常用于替代一些需要高效查找、插入和删除操作的平衡二叉树场景，例如在数据库的索引实现中，跳表可以作为一种可选的数据结构来加快数据的检索速度。

• 在一些缓存系统中，管理缓存数据的有序集合时，跳表也能发挥很好的作用，提供较快的查找和更新操作性能。

C语言实现示例

以下是一个简单的跳表实现示例，实现了基本的插入、查找和打印功能，为了方便演示，这里的跳表最大层数设置为固定值（实际应用中可动态调整），且节点提升为索引节点的概率也是简化处理的：

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

// 定义跳表节点结构体
typedef struct SkipListNode {
    int key;
    int value;
    struct SkipListNode **forward;  // 指向各级索引链表的下一个节点的指针数组
} SkipListNode;

// 定义跳表结构体
typedef struct SkipList {
    SkipListNode *header;  // 头节点，方便操作
    int level;  // 当前跳表的最大层数
} SkipList;

// 创建跳表节点
SkipListNode* createNode(int key, int value, int level) {
    SkipListNode *node = (SkipListNode *)malloc(sizeof(SkipListNode));
    if (node == NULL) {
        return NULL;
    }
    node->key = key;
    node->value = value;
    node->forward = (SkipListNode **)malloc((level + 1) * sizeof(SkipListNode *));  // 分配指针数组空间
    for (int i = 0; i <= level; i++) {
        node->forward[i] = NULL;
    }
    return node;
}

// 创建跳表
SkipList* createSkipList(int maxLevel) {
    SkipList *list = (SkipList *)malloc(sizeof(SkipList));
    if (list == NULL) {
        return NULL;
    }
    list->header = createNode(-1, -1, maxLevel);  // 头节点的key和value设为特殊值，方便操作
    list->level = 0;
    return list;
}

// 随机生成节点的层数，这里简单模拟，实际可更精细设置概率
int randomLevel(int maxLevel) {
    int level = 0;
    while (rand() % 2 == 0 && level < maxLevel) {  // 例如以50%概率提升一层，最多到maxLevel层
        level++;
    }
    return level;
}

// 插入元素到跳表
void insert(SkipList *list, int key, int value) {
    SkipListNode *update[16];  // 用于记录每一层插入位置的前一个节点，假设最大16层，可根据实际调整
    SkipListNode *current = list->header;

    for (int i = list->level; i >= 0; i--) {  // 从最高层开始查找合适的插入位置
        while (current->forward[i]!= NULL && current->forward[i]->key < key) {
            current = current->forward[i];
        }
        update[i] = current;
    }

    current = current->forward[0];  // 到达最底层对应位置

    if (current == NULL || current->key!= key) {  // 如果不存在相同key的节点则插入新节点
        int newLevel = randomLevel(15);  // 生成新节点的层数，假设最大16层，这里可调整
        if (newLevel > list->level) {  // 如果新节点层数大于当前跳表最大层数，更新高层索引
            for (int i = list->level + 1; i <= newLevel; i++) {
                update[i] = list->header;
            }
            list->level = newLevel;
        }

        SkipListNode *newNode = createNode(key, value, newLevel);
        for (int i = 0; i <= newLevel; i++) {
            newNode->forward[i] = update[i]->forward[i];
            update[i]->forward[i] = newNode;
        }
    }
}

// 在跳表中查找元素
SkipListNode* search(SkipList *list, int key) {
    SkipListNode *current = list->header;
    for (int i = list->level; i >= 0; i--) {  // 从最高层开始查找
        while (current->forward[i]!= NULL && current->forward[i]->key < key) {
            current = current->forward[i];
        }
    }
    current = current->forward[0];  // 到达最底层对应位置
    if (current!= NULL && current->key == key) {
        return current;
    }
    return NULL;
}

// 打印跳表，用于查看跳表结构（简单按层打印节点key）
void printSkipList(SkipList *list) {
    for (int i = list->level; i >= 0; i--) {
        SkipListNode *current = list->header->forward[i];
        printf("Level %d: ", i);
        while (current!= NULL) {
            printf("%d ", current->key);
            current = current->forward[i];
        }
        printf("\n");
    }
}

int main() {
    srand((unsigned int)time(NULL));  // 初始化随机数种子
    SkipList *list = createSkipList(15);  // 创建最大层数为15的跳表

    insert(list, 1, 10);
    insert(list, 3, 30);
    insert(list, 5, 50);
    insert(list, 7, 70);

    printSkipList(list);

    SkipListNode *found = search(list, 5);
    if (found!= NULL) {
        printf("Found key 5 with value %d\n", found->value);
    }

    return 0;
}
注释解释如下：
// 定义跳表节点结构体
typedef struct SkipListNode {
    int key;  // 节点存储的键值，用于排序和查找
    int value;  // 节点对应的值，可以根据实际需求存储各种数据
    struct SkipListNode **forward;  // 指向各级索引链表的下一个节点的指针数组，通过不同索引层进行“跳跃”查找
} SkipListNode;

// 定义跳表结构体
typedef struct SkipList {
    SkipListNode *header;  // 头节点，方便操作，其本身不存储实际数据，主要用于在查找等操作中便于从最高层索引开始遍历
    int level;  // 当前跳表的最大层数，即索引的层数，初始为0，会随着插入节点可能增加
} SkipList;

// 创建跳表节点
SkipListNode* createNode(int key, int value, int level) {
    SkipListNode *node = (SkipListNode *)malloc(sizeof(SkipListNode));
    if (node == NULL) {
        return NULL;
    }
    node->key = key;
    node->value = value;
    node->forward = (SkipListNode **)malloc((level + 1) * sizeof(SkipListNode *));  // 分配指针数组空间，根据节点层数确定数组大小，用于指向各级索引下一个节点
    for (int i = 0; i <= level; i++) {
        node->forward[i] = NULL;
    }
    return node;
}

// 创建跳表
SkipList* createSkipList(int maxLevel) {
    SkipList *list = (SkipList *)malloc(sizeof(SkipList));
    if (list == NULL) {
        return NULL;
    }
    list->header = createNode(-1, -1, maxLevel);  // 头节点的key和value设为特殊值，方便操作，比如在查找时便于从最高层开始比较
    list->level = 0;
    return list;
}

// 随机生成节点的层数，这里简单模拟，实际可更精细设置概率
int randomLevel(int maxLevel) {
    int level = 0;
    while (rand() % 2 == 0 && level < maxLevel) {  // 例如以50%概率提升一层，最多到maxLevel层，通过随机方式决定节点是否成为更高级索引节点
        level++;
    }
    return level;
}

// 插入元素到跳表
void insert(SkipList *list, int key, int value) {
    SkipListNode *update[16];  // 用于记录每一层插入位置的前一个节点，假设最大16层，可根据实际调整，方便后续插入新节点时修改指针指向
    SkipListNode *current = list->header;

    for (int i = list->level; i >= 0; i--) {  // 从最高层开始查找合适的插入位置，利用高层索引快速定位大概范围
        while (current->forward[i]!= NULL && current->forward[i]->key < key) {
            current = current->forward[i];
        }
        update[i] = current;
    }

    current = current->forward[0];  // 到达最底层对应位置

    if (current == NULL || current->key!= key) {  // 如果不存在相同key的节点则插入新节点
        int newLevel = randomLevel(15);  // 生成新节点的层数，假设最大16层，这里可调整，根据概率决定新节点层数
        if (newLevel > list->level) {  // 如果新节点层数大于当前跳表最大层数，更新高层索引，将高层索引的插入位置指向头节点
            for (int i = list->level + 1; i <= newLevel; i++) {
                update[i] = list->header;
            }
            list->level = newLevel;
        }

        SkipListNode *newNode = createNode(key, value, newNodeLevel);
        for (int i = 0; i <= newLevel; i++) {
            newNode->forward[i] = update[i]->forward[i];
            update[i]->forward[i] = newNode;
        }
    }
}

// 在跳表中查找元素
SkipListNode* search(SkipList *list, int key) {
    SkipListNode *current = list->header;
    for (int i = list->level; i >= 0; i--) {  // 从最高层开始查找，利用索引快速缩小查找范围
        while (current->forward[i]!= NULL && current->forward[i]->key < key) {
            current = current->forward[i];
        }
    }
    current = current->forward[0];  // 到达最底层对应位置
    if (current!= NULL && current->key == key) {
        return current;
    }
    return NULL;
}

// 打印跳表，用于查看跳表结构（简单按层打印节点key）
void printSkipList(SkipList *list) {
    for (int i = list->level; i >= 0; i--) {
        SkipListNode *current = list->header->forward[i];
        printf("Level %d: ", i);
        while (current!= NULL) {
            printf("%d ", current->key);
            current = current->forward[i];
        }
        printf("\n");
    }
}

int main() {
    srand((unsigned int)time(NULL));  // 初始化随机数种子，确保每次运行生成不同随机结果
    SkipList *list = createSkipList(15);  // 创建最大层数为15的跳表

    insert(list, 1, 10);
    insert(list, 3, 30);
    insert(list, 5, 50);
    insert(list, 7, 70);

    printSkipList(list);

    SkipListNode *found = search(list, 5);
    if (found!= NULL) {
        printf("Found key 5 with value %d\n", found->value);
    }

    return 0;
}

请注意，上述代码只是一个简单的跳表实现示例，实际应用中的跳表还可以进一步优化，比如更合理地设置索引节点提升概率、动态调整跳表最大层数、完善错误处理以及增加更多操作方法等，不过它展示了跳表的基本原理和核心操作的实现思路。

【C语言】算法学习·跳表
m0_64560763的博客
07-26 719
挑表实现
C语言实现跳表数据结构超详细教程（图解+代码逐行分析）
最新发布
sanyueqi520的博客
04-20 561
cint key;// 节点存储的值int level;// 所在层级（0为最底层）// 同层下一节点指针// 下层对应节点指针// 上层对应节点指针} Node;内存结构cNode* head;// 头节点（各层链表起点）Node* tail;// 尾节点（各层链表终点）// 最大层级限制} Skiplist;初始化示例实现要点多层链表的垂直连接管理概率晋升机制实现高效的查找路径优化扩展方向实现节点删除功能添加自动调整层级功能实现范围查询操作应用场景Redis有序集合。
7.2 跳跃表（skiplist）—— C语言实现
qq_43067403的博客
04-20 1454
本章内容参考海贼宝藏胡船长的数据结构与算法中的第七章——查找算法，侵权删。查找的时间复杂度能从原来链表的OnO(n)On降到OlognO(logn)Ologn，典型的用空间复杂度换时间复杂度的例子。直观上感受就是把原来的链表给拉升了，处于同一高度的节点被串联成了一个单独的链表，每个链表都有一个层高第0层：1，6，15，30第1层：1，6，15，30第2层：1，15，30第3层：1，15第4层：15有层高，每一层又是单独的链表。
C语言跳表(skiplist)实现
weixin_34202952的博客
06-02 432
一、简介 跳表（skiplist）是一个非常优秀的数据结构，实现简单，插入、删除、查找的复杂度均为O(logN)。LevelDB的核心数据结构是用跳表实现的，redis的sorted set数据结构也是有跳表实现的。代码在这里：http://flyingsnail.blog.51cto.com/5341669/1020034   二、跳表图解 考虑一个有序表： 从该有序表中搜索元素 &lt;...
跳表C语言实现详解
hurryddd
12-25 4052
目录 一、跳表（skip list）简介 1、时间复杂度分析 2、跳表索引动态更新 二、跳表数据存储模型 三、跳表操作 1、初始化 2、插入 3、删除 4、修改 5、查询 5、销毁 参考链接 一、跳表（skip list）简介 跳表使用空间换时间的设计思路，通过构建多级索引来提高查询的效率，实现了基于链表的“二分查找”。跳表是一种动态数据结构，支持快速的插入、删除、查找...
一文彻底搞懂跳表的各种时间复杂度、适用场景以及实现原理
热门推荐
qq_34412579的博客
09-30 2万+
跳表是一种神奇的数据结构，因为几乎所有版本的大学本科教材上都没有跳表这种数据结构，而且神书《算法导论》、《算法第四版》这两本书中也没有介绍跳表。但是跳表插入、删除、查找元素的时间复杂度跟红黑树都是一样量级的，时间复杂度都是O(logn)，而且跳表有一个特性是红黑树无法匹敌的（具体什么特性后面会提到）。所以在工业中，跳表也会经常被用到。废话不多说了，开始今天的跳表学习。 通过本文，你能 get 到以...
C语言实现函数查表跳转程序
07-29
本文给出C语言实现函数查表跳转程序，感兴趣的朋友可以看看。
C++实现基于跳表实现的轻量级键值型存储引擎，
06-05
C++是一种面向对象的计算机程序设计语言，由美国AT&T贝尔实验室的本贾尼·斯特劳斯特卢普博士在20世纪80年代初期发明并实现（最初这种语言被称作“C with Classes”带类的C）。它是一种静态数据类型检查的、支持多重...
基于跳表实现的轻量级键值型存储引擎，使用C++实现。
06-05
C++是一种面向对象的计算机程序设计语言，由美国AT&T贝尔实验室的本贾尼·斯特劳斯特卢普博士在20世纪80年代初期发明并实现（最初这种语言被称作“C with Classes”带类的C）。它是一种静态数据类型检查的、支持多重...
c语言实现跳表（skiplist）
m0_63251896的博客
01-12 1422
c语言实现跳表（skiplist）
数据结构（基于C语言）---跳跃表实现
2201_75324641的博客
05-15 213
每一个结点都随机分为不同的层数，除第一层外，每一层均跳跃着连接结点。
c语言实现连表代码,跳表的实现c语言源代码
weixin_30314045的博客
05-19 351
#define _CRT_SECURE_NO_WARNINGS//怎么让回车的时候之前内容不清空，删除的时候出错是队列最尾的删除成功但出现error(打印出来的)#include#include#include#define maxlevel 7#define false -1#define true 1typedef struct node{int value;struct node *next...
跳表的C语言实现
sekaii的专栏
02-18 335
跳表（Skip List）是一种基于链表的动态数据结构，用于实现高效的查找、插入和删除操作。它通过引入多级索引来加速查找过程，类似于多级索引的有序链表。跳表的平均时间复杂度为 O(logn)，在某些场景下可以替代平衡树。以下是跳表的基本实现思路和一个简单的 C 语言实现示例。
跳跃函数c语言编程,跳跃表实现文件C语言
weixin_40002009的博客
05-20 534
祝自己,情人节快乐.今天是正月十五.在家研究了一天收费公路重建问题.可耻的是,居然目前还没有搞正确.倒是发现,原来的跳跃表有问题.还好,这个问题正确地解决了./* SkipList.c -- 跳跃表实现文件 */ #include "SkipList.h" /* 局部函数声明 */ static int logTwo (const int value) ; static void endow (I...
跳表
lukeyyanghang的博客
01-27 202
什么是跳表? 跳表是一个相对于链表来说的高级动态数据结构。 在一个有序的链表当中，以一定的规则(比如说3个数字建立一个索引)建立索引，依次建立。最高的索引层只有2个索引。 时间复杂度是O(logn)，十分高效。基本思想就是以空间换时间，建立索引。 在大规模软件开发中，这个额外的空间相对于数据的大小可以忽略。   如何插入? 插入跳表一个比较恶心的东西就是需要更新索引。 更新索引的方...
C语言经典算法之跳跃表算法
weixin_56154577的博客
02-28 1079
跳跃表（Skip List）是一种高效的数据结构，它通过引入多级索引的方式实现了近似于平衡树的查找、插入和删除操作的平均时间复杂度为O(log_2N)的功能，但它比平衡树更容易理解和实现。
跳表的 c++ 代码
weixin_35756624的博客
02-14 104
很抱歉，作为一个语言模型，我不能直接提供代码。但是我可以提供一些关于如何实现跳表的概念和技巧。 跳表是一种数据结构，其中的每个节点都包含了一个关键字和多个指向其他节点的指针，这些指针允许快速访问表中的其他元素。在 C 语言中实现跳表通常需要使用结构体和指针。 以下是一个简单的 C 语言代码示例，实现了一个简单的跳表： #include <stdio.h> #include <st...
【LeetCode 1206】 设计跳表，C语言实现
pcj_888的博客
12-05 1711
跳跃表简介 跳跃表是一种以O(log N)期望时间支持查找、插入、删除操作的、有序的数据结构。其性能和红黑树相当，且跳跃表实现更为简单。 如何理解”跳跃“二字 首先，考察一个有序的单链表。如下图所示，该链表由8个元素组成，为了查找元素14，需要依次遍历 2 -> 4 -> 6 -> 8 -> 10 -> 12 -> 14, 共考察7个节点。考察的节点数正比于链表长度，查找的时间复杂度为O(n)，效率很低。 为了加快查找速度，可以对单链表进行改造，每隔一个节点新增
Skip List（跳跃表）原理详解与实现
qiudesuo的专栏
10-25 887
Skip List（跳跃表）原理详解与实现   本文内容框架： §1 Skip List 介绍 §2 Skip List 定义以及构造步骤   §3 Skip List 完整实现 §4 Skip List 概率分析 §5 小结       §1 S...
掌握C语言中的跳表技术
此外，虽然跳表在C语言中的实现可能需要一些指针操作的技巧，但是它的核心概念并不复杂，且一旦实现之后，其操作的性能保证是相当吸引人的。在学习跳表的过程中，理解其基本原理和结构设计是非常关键的，这有助于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

请向我看齐

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值