嵌入式中一文搞定C语言数据结构--跳表

news2025/2/11 12:50:31

大家好，今天分享一篇C语言数据结构相关的文章--跳表。

1. 什么是跳表

跳表是 链表 + 索引 的一种数据结构 ，是以空间换取时间的方式，关于跳表参考:

 https://baike.baidu.com/item/跳表/22819833?fr=aladdin

2. 跳表概念

跳表在原有链表的基础上，增加索引，从而可以进行二分查找，提高搜寻效率。

原始链表

Head ——> 1 ——> 8 ——> 12 ——> 23 ——> 55 ——> NULL

新增了索引的链表(跳表)

Head2 ————————> 8 ———————————————————————> NULL 
Head1 ————————> 8 —————————> 23 —————————> NULL 
Head0 ——> 1 ——> 8 ——> 12 ——> 23 ——> 55 ——> NULL

Head0 , Head1 , Head2 上都是真实的节点，这就是以空间换取时间

例如算上Head, 元素数据一共有 6 个，而添加索引后，元素一共有 11 个

3. 跳表增删查规则

3.1 跳表数据节点

数据节点可以和链表节点一致 ，也可以定义如下节点，除了数据外，有指针指向 前一个/后一个/上一个/下一个 节点，以便后续查找操作。

typedef struct {
        int data;
        struct Node *next; // 后一个节点
        struct Node *last; // 前一个节点
        struct Node *up; // 上一个节点
        struct Node *down; // 下一个节点
} Node;

3.2 跳表初始化

当跳表有多少层的时候，应当建立多少个头结点，例如: 跳表为3层

Head2 ——> NULL
Head1 ——> NULL
Head0 ——> NULL

3.3 查找

删除/新增 都会进行查询才操作，无非是删除/新增索引而已。

例如有如下数据

Head2 —————————————————————> 23 —————————> NULL 
Head1 ————————> 8 —————————> 23 —————————> NULL 
Head0 ——> 1 ——> 8 ——> 12 ——> 23 ——> 55 ——> NULL

要查找 13这个节点

去除无效层

例如: Head2 后面第一个节点的数据 23 ， 而 23 大于 13 , 所以 Head2 没有数据匹配查询，故需要跳到下面一层，至 Head1 上进行查询。

查询至Head0层

去除无效层后数据进入了 Head1 , 在Head1上进行匹配，当匹配到 23 时，23大于13，将23标记为 查询结束点，对23的上一个节点 8 进行 向下指针操作，进入 Head0层的8节点。

查找实际数据

从Head0层的8 进行查找，直至 查询结束标记点(head1 23), 查询的数据分别为 8 ， 12 ，23 查询结束，未找到数据。

3.4 新增

新增操作需要记录索引寻址过程，以便后续新增索引。

头结点插入

头结点插入一定是 去除无效层 至Head0 , 且 Head0的第一个节点都比插入节点要大的情况下

例如:

如下跳表，插入 2

Head2 —————————————————————> 23 —————————> NULL 
Head1 ————————> 8 —————————> 23 —————————> NULL 
Head0 ——> 3 ——> 8 ——> 12 ——> 23 ——> 55 ——> NULL

尾结点插入

头结点插入一定是 去除无效层 至Head0 , 且 Head0的第一个节点都比插入节点要小，直至NULL节点的情况下

例如:

如下跳表，插入 65

Head2 —————————————————————> 23 —————————> NULL 
Head1 ————————> 8 —————————> 23 —————————> NULL 
Head0 ——> 3 ——> 8 ——> 12 ——> 23 ——> 55 ——> NULL

中间节点插入

除开以上2种情况，其余情况为 中间节点插入

新增索引

抛硬币的方法，当数据量达到一定规模的时候，一定是趋近于 50%的。

所以跳表会越来越趋向于如下形式

    3
    3       7
1   3   5   7   9
1 2 3 4 5 6 7 8 9

判断是否需要新增索引，采取抛硬币的方法来判断，即: 随机数 取余 为 0 则需要新增，否则不需要。

例如如下跳表，插入 65

Head2 —————————————————————> 23 —————————> NULL 
Head1 ————————> 8 —————————> 23 —————————> NULL 
Head0 ——> 3 ——> 8 ——> 12 ——> 23 ——> 55 ——> NULL

寻址应该为
Head2: 23
Head1: 23

元素数据插入后为

Head2 —————————————————————> 23 ———————————————> NULL 
Head1 ————————> 8 —————————> 23 ———————————————> NULL 
Head0 ——> 3 ——> 8 ——> 12 ——> 23 ——> 55 ——> 65 —> NULL

当插入65节点后，若判断需要索引的时候，则先为 Head1 添加索引，添加位置为 寻址地址之后，寄 Head1: 23

Head2 —————————————————————> 23 ———————————————> NULL 
Head1 ————————> 8 —————————> 23 —————————> 65 —> NULL 
Head0 ——> 3 ——> 8 ——> 12 ——> 23 ——> 55 ——> 65 —> NULL

继续判断，若不需要添加索引，则插入结束

若还需要添加索引，则继续上述操作，直至 索引层 达到最高层

3.5 删除

删除首先是查找操作【3.3 查找】

若未找到该节点，则删除失败

若找到了该节点，则应当提到该数据最高索引层，再从高到低删除

例如:

如下跳表，删除 23

Head2 —————————————————————> 23 ———————————————> NULL 
Head1 ————————> 8 —————————> 23 —————————> 65 —> NULL 
Head0 ——> 3 ——> 8 ——> 12 ——> 23 ——> 55 ——> 65 —> NULL

找到 Head0 23 后，应该向上找到 Head2 23 ,然后从高向低删除，若删除后，该索引没有数据了，则索引层减1

则删除Head2 23 后数据如下

Head1 ————————> 8 —————————> 23 —————————> 65 —> NULL 
Head0 ——> 3 ——> 8 ——> 12 ——> 23 ——> 55 ——> 65 —> NULL

删除Head1 23 后数据如下

Head1 ————————> 8 ———————————————————————> 65 —> NULL 
Head0 ——> 3 ——> 8 ——> 12 ——> 23 ——> 55 ——> 65 —> NULL

删除Head0 23后数据如下

Head1 ————————> 8 ————————————————> 65 —> NULL 
Head0 ——> 3 ——> 8 ——> 12 ——> 55 ——> 65 —> NULL

4. 代码

skipList.c

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

int MaxLevel = 8; // 最大层数
int currLevel = 0; // 当前层数

// 数据节点
typedef struct {
        int data;
        struct Node *next;
        struct Node *last;
        struct Node *up;
        struct Node *down;
} Node;

// 记录索引寻址过程
typedef struct {
        int level;
        struct Node *node;
} skipStep;

// 判断是否需要新增索引, 抛硬币
bool randNum() {
        if(0 == (rand() % 2))
                return true;

        return false;
}

// 新增节点
bool add(Node *SL[] , int data) {

        printf("新增节点: %d\n",data);
        int level = currLevel;

        Node *Head = NULL;
        Node *tmp = NULL;
        Node *last = NULL;

        // 初始化索引 数据为 Head 地址
        skipStep steps[MaxLevel];
        int i;
        for (i=0;i<MaxLevel;i++) {
                steps[i].level = 0;
                steps[i].node = SL[i];
                Node *ss = steps[i].node;
        }


        // 赛选无效层
        Head = SL[level];
        tmp = Head->next;

        while ((level > 0) && (data < tmp->data)) {
                level--;
                Head = SL[level];
                tmp = Head->next;
        }

        // 根据索引寻找Head0数据节点
        while ((level > 0)) {

                while (tmp != NULL) {
                        if (data < tmp->data) {
                                steps[level].level = level;
                                if (NULL != last) 
                                        steps[level].node = last;
                                tmp = last->down;
                                level--;
                                break;
                        }

                        last = tmp;
                        tmp = tmp->next;
                }
                if (NULL == tmp) {
                        steps[level].level = level;
                        if (NULL != last) 
                                steps[level].node = last;
                        tmp = last->down;
                        level--;

                }
        }

        // Head0 数据合适的节点
        while (tmp != NULL) {
                if (data < tmp->data) {
                        break;
                }
                last = tmp;
                tmp = tmp->next;
        }

        // 新增节点
        Node *newData = (Node *)malloc(sizeof(Node));
        newData->data = data;
        newData->up = NULL;
        newData->down = NULL;
        newData->last = NULL;
        newData->next = NULL;

        int k = 0;

        // Head0 插入原始数据
        if (NULL == last ) {
                // 头结点

                Head = SL[0];
                Node *headNext = Head->next;
                if (NULL != headNext) {
                        newData->next = headNext;
                        headNext->last = newData;

                        newData->last = Head;


                } 

                Head->next = newData;
                newData->last = Head;


        } else if ( NULL == tmp) {
                // 尾节点
                last->next = newData;
                newData->last = last;


        } else {
                // 中间节点
                newData->next = tmp;
                tmp->last = newData;

                newData->last = last;
                last->next = newData;
        }

        // 构建索引
        while (randNum()) {
                k++;
                if (k >= MaxLevel) break;

                // 新增索引数据
                Node *newIndex = (Node *)malloc(sizeof(Node));
                newIndex->data = data;
                newIndex->up = NULL;
                newIndex->down = NULL;
                newIndex->next = NULL;
                newIndex->last = NULL;

                // 建立上下级关系
                newIndex->down = newData;
                newData->up = newIndex;

                Node *node = steps[k].node;

                // node->next
                Node *nextIndex = node->next;


                node->next = newIndex;
                newIndex->last = node;

                newIndex->next = nextIndex;
                if (NULL != nextIndex) 
                        nextIndex->last = newIndex;

                newData = newIndex;

                // 判断是否需要新增索引层数
                if (k > currLevel) 
                        currLevel = k;
        }
}


// 初始化头结点
Node *initSkipList(Node *skipList[]) {
        int i;
        for (i=0;i<MaxLevel;i++) {
                Node *newHead = (Node *)malloc(sizeof(Node));
                if (NULL == newHead) {
                        printf("%d 层 头结点申请失败\n");
                        return NULL;
                }
                newHead->data = -1-i;
                newHead->down = NULL;
                newHead->up = NULL;
                newHead->next = NULL;
                newHead->last = NULL;

                skipList[i] = newHead;


        }
        return skipList;
}

// 打印跳表数据
void PrintSkipList(Node *SL[]) {
        if (NULL == SL) {
                return;
        };

        int level = currLevel;
        //int level = MaxLevel;

        int i;
        for (i=level;i>=0;i--) {
                Node *Head = SL[i];

                Node *tmp = Head->next;
                printf("第%d层\t\t",i);
                while (NULL != tmp) {
                        printf(" %d\t",tmp->data);

                        tmp = tmp->next;
                }
                printf("\n");
        }
}

// 查询数据
Node *query(Node *SL[] , int data) {
        printf("查询数据: %d\n",data);

        int level = currLevel;

        Node *Head = NULL;
        Node *tmp = NULL;
        Node *last = NULL;

        Head = SL[level];
        tmp = Head->next;
        int endQuery = -1;

        // 筛除无效层
        while ((level > 0) && (data < tmp->data)) {
                level--;
                endQuery = tmp->data;
                Head = SL[level];
                tmp = Head->next;
        }

        // 根据索引定位到Head0层
        while ((level > 0 )) {

                while (tmp != NULL) {
                        if (data < (tmp->data)) {
                                level--;
                                endQuery = tmp->data;
                                tmp = last->down;
                                break;
                        }

                        last = tmp;
                        tmp = tmp->next;
                }
                if (NULL == tmp) {
                        tmp = last->down;
                        endQuery = -1;
                        level--;
                }

        }

        // 查询实际数据
        while (NULL != tmp) {
                if (endQuery != -1)
                        if (tmp->data > endQuery) {
                                        tmp = NULL;
                                        break;
                        }
                if (tmp->data == data) {
                        break;
                }
                tmp = tmp->next;
        }
        // 返回查询的数据节点，若没有查询到，应当返回NULL ,否则返回实际的地址
        return tmp;
}

// 删除数据
bool del(Node *SL[],int data) {
        printf("删除数据: %d\n",data);

        // 找到节点地址
        Node *tmp = query(SL,data);

        if (NULL == tmp) {
                printf("未找到节点,删除失败\n");
                return false;
        }
        int level = 0;
        Node *t_last = NULL;
        Node *t_next = NULL;


        // 找到该数据最高索引
        while (NULL != tmp->up) {
                level++;
                tmp = tmp->up;
        }

        // 由上至下删除索引/数据
        while (tmp != NULL) {
                t_last = tmp->last;
                t_next = tmp->next;

                Node *t_down = tmp->down;

                if (t_last == NULL) {
                        printf("上一个节点不可能为空，删除失败,层数: %d\n",level);
                        return false;
                }

                t_last->next = t_next;

                if (NULL != t_next)
                        t_next->last = t_last;
                else
                        t_last->next = NULL;

                if ((t_last == SL[level]) && (NULL == t_next)) {
                        currLevel--;

                }
                free(tmp);

                tmp = t_down;
                level--;
        }

        return true;


}

int main() {

        Node *SL[MaxLevel];

        Node *skipList = initSkipList(SL);
        if (NULL == SL) {
                printf("skipList 申请失败\n");
                return -1;
        }

        // 测试新增
        int num[] = {1,3,2,10,8,9,22,30,29,120,99,78,55,76,21};
        int i;
        for (i=0;i<sizeof(num)/sizeof(int);i++) {
                add(skipList,num[i]);
        }
        PrintSkipList(SL);

        // 测试删除
        int delNum[] = {99,9,78,55,3,1,28,78};
        for (i=0;i<sizeof(delNum)/sizeof(int);i++) {
                del(skipList,delNum[i]);
        }
        PrintSkipList(SL);

        printf("\n");
        return 0;
}

执行结果

# gcc skipList.c -w -g
# ./a.out 
新增节点: 1
新增节点: 3
新增节点: 2
新增节点: 10
新增节点: 8
新增节点: 9
新增节点: 22
新增节点: 30
新增节点: 29
新增节点: 120
新增节点: 99
新增节点: 78
新增节点: 55
新增节点: 76
新增节点: 21
第5层            99
第4层            99
第3层            76      99
第2层            9       76      99
第1层            3       9       29      30      76      78      99
第0层            1       2       3       8       9       10      21      22      29      30      55      76      78      99      120
删除数据: 99
查询数据: 99
删除数据: 9
查询数据: 9
删除数据: 78
查询数据: 78
删除数据: 55
查询数据: 55
删除数据: 3
查询数据: 3
删除数据: 1
查询数据: 1
删除数据: 28
查询数据: 28
未找到节点,删除失败
删除数据: 78
查询数据: 78
未找到节点,删除失败
第3层            76
第2层            76
第1层            29      30      76
第0层            2       8       10      21      22      29      30      76      120

#

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1335650.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

SPFA算法总结

SPFA算法总结

知识概览 SPFA算法是Bellman_Ford算法的优化。时间复杂度一般是O(m)&#xff0c;最坏时间复杂度是O(nm)&#xff08;遇到网格图、菊花图&#xff09;&#xff0c;其中n是点数&#xff0c;m是边数。SPFA算法其实是单源最短路限制最小的算法&#xff0c;只要图中没有负环&#xf…
阅读更多...
【MYSQL】MYSQL 的学习教程（八）之 12 种慢 SQL 查询原因

【MYSQL】MYSQL 的学习教程（八）之 12 种慢 SQL 查询原因

日常开发中&#xff0c;我们经常会遇到数据库慢查询。那么导致数据慢查询都有哪些常见的原因呢&#xff1f;今天就跟大家聊聊导致 MySQL 慢查询的 12 个常见原因&#xff0c;以及对应的解决方法&#xff1a; SQL 没加索引SQL 索引失效limit 深分页问题单表数据量太大join 或者…
阅读更多...
一起玩儿物联网人工智能小车（ESP32）——13. 用ESP32的GPIO控制智能小车运动起来（一）

一起玩儿物联网人工智能小车（ESP32）——13. 用ESP32的GPIO控制智能小车运动起来（一）

摘要&#xff1a;本文更深入的讲述了GPIO的相关知识&#xff0c;并完成了导线连接工作&#xff0c;为下一步的软件开发做好了准备。 通用输入输出端口&#xff08;GPIO&#xff1a;General Purpose Input/Output Port&#xff09;&#xff0c;在前面已经有了初步的介绍&#xf…
阅读更多...
C++ 比 C语言增加的新特性 3 之 命名空间namespace

C++ 比 C语言增加的新特性 3 之 命名空间namespace

1. 命名空间 1.1 命名空间 又称为“名字空间”&#xff0c;在内存&#xff08;全局&#xff09;中取一块区域并对其进行命名 实际例子&#xff1a; 同一个班级&#xff0c;两个同姓的人&#xff0c;例如&#xff1a;张三和张三&#xff0c;其中一个张三座位是在讲台右边&am…
阅读更多...
公开100GB数据，日产汽车遭勒索组织“撕票”

公开100GB数据，日产汽车遭勒索组织“撕票”

Bleeping Computer 网站消息&#xff0c;Akira 勒索软件团伙声称成功入侵了日本汽车制造商日产汽车澳大利亚分公司的内部网络系统。 12 月 22 日&#xff0c;Akira 勒索软件团伙在其泄漏博客上添加了一个新的“受害者”&#xff0c;并表示其成员从日产汽车制造商的内部网络系统…
阅读更多...
docker的一些思考

docker的一些思考

1.docker是啥&#xff1f; 2.镜像执行流程 3.一些疑惑和解答 1. 2.
阅读更多...
软件测试面试--说一个印象最深的bug？

软件测试面试--说一个印象最深的bug？

其实&#xff0c;面试官并不关心你描述的这个bug是否真的有价值&#xff0c;或有多曲折离奇&#xff1f;他只是&#xff1a; 1.了解你平时工作中的测试能力 所以&#xff0c;这就要求的你平时工作中遇到bug时试着自己去定位&#xff0c;定位bug的过程远比你的单纯的执行测试用…
阅读更多...
【隐私保护】使用Python从文本中删除个人信息:第一部分

【隐私保护】使用Python从文本中删除个人信息:第一部分

自我介绍 做一个简单介绍&#xff0c;酒架年近48 &#xff0c;有20多年IT工作经历&#xff0c;目前在一家500强做企业架构&#xff0e;因为工作需要&#xff0c;另外也因为兴趣涉猎比较广&#xff0c;为了自己学习建立了三个博客&#xff0c;分别是【全球IT瞭望】&#xff0c;【…
阅读更多...
销售如何挖掘客户？有哪些方法？

销售如何挖掘客户？有哪些方法？

在当今竞争激烈的市场环境中&#xff0c;客户资源的挖掘已经成为企业生存和发展的关键。销售人员需要掌握一定的技巧和方法&#xff0c;以有效地发掘潜在客户&#xff0c;提高销售业绩。以下分享一些挖掘客户的常用方法&#xff0c;帮助销售人员更好地开展业务。 一、了解客户需…
阅读更多...
matlab附加功能管理器安装蓝牙工具箱

matlab附加功能管理器安装蓝牙工具箱

由于最近需要做蓝牙仿真方面的东西&#xff0c;需要用到matlab的蓝牙工具箱&#xff0c;根据官网例子输入&#xff1a; commSupportPackageCheck(BLUETOOTH);检测是否包含该工具箱&#xff0c;结果出现&#xff1a; 点击Add-On-Explorer出现&#xff1a; 网上搜索发现这是因为…
阅读更多...
麦肯锡产品经理问题解决流程终极指南

麦肯锡产品经理问题解决流程终极指南

您是否想知道世界上最成功的产品经理如何始终如一地提供不仅满足而且超出预期的解决方案&#xff1f;秘密可能就在于世界上最负盛名的咨询公司之一麦肯锡公司所磨练的方法论。本文深入探讨了麦肯锡的问题解决流程&#xff0c;该流程专为希望提升水平的产品经理量身定制。 01. 麦…
阅读更多...
周末两个比赛3个小题

周末两个比赛3个小题

周末安洵和nctf&#xff0c;因为不是学生也没报名拿附件作了一把。 安洵/pwn/side_channel , initiate 安洵的题很好&#xff0c;唯一的问题是把几乎所有的&#xff0c;有没有必要的都放了远程&#xff0c;而且服务器很差&#xff0c;好多题不是不会而是连不上。 这个题估计…
阅读更多...
vivado 多周期路径与时钟相移

vivado 多周期路径与时钟相移

多周期路径与时钟相移 有时&#xff0c;必须在具有相同时钟域的两个时钟域之间定义定时约束时钟周期&#xff0c;但两个时钟之间的相移。在这些情况下&#xff0c;理解正时引擎使用的默认设置和保持关系。如果没有仔细调整两个时钟之间的相移可能导致两个时钟间的逻辑约束过大…
阅读更多...
13.TCP/IP协议

13.TCP/IP协议

1.TCP/IP协议是什么 TCP/IP协议不仅仅指的是TCP和IP两个协议&#xff0c;二十指由FTP、SMTP、TCP、UDP、IP等等协议构成的协议簇。 TCP/IP协议是一系列规则的统称&#xff0c;他们定义了消息在网络间进行传输的规则。是供已连接互联网的设备进行通信的通信规则 2.TCP/IP协议的…
阅读更多...
走进数字金融峰会，为金融科技数字化赋能

走进数字金融峰会，为金融科技数字化赋能

12月20—21日&#xff0c;FSIDigital数字金融峰会在上海圆满召开。本次峰会包含InsurDigital数字保险峰会和B&SDigital数字银行与证券峰会2场平行峰会&#xff1b;吸引了近600位来自保险、银行、证券以及金融科技等行业的领导者和专家齐聚一堂&#xff0c;共同探讨金融业数…
阅读更多...
宝塔面板Linux服务器CentOS 7数据库mysql5.6升级至5.7版本教程

宝塔面板Linux服务器CentOS 7数据库mysql5.6升级至5.7版本教程

近段时间很多会员问系统更新较慢&#xff0c;也打算上几个好的系统&#xff0c;但几个系统系统只支持MYSQL5.7版本&#xff0c;服务器一直使用较低的MYSQL5.6版本&#xff0c;为了测试几个最新的系统打算让5.6和5.7并存使用&#xff0c;参考了多个文档感觉这种并存问题会很多。…
阅读更多...
STM32 支持IAP的bootloader开发，使用串口通过Ymodem协议传输固件

STM32 支持IAP的bootloader开发，使用串口通过Ymodem协议传输固件

资料下载: https://download.csdn.net/download/vvoennvv/88658447 一、概述 关于IAP的原理和Ymodem协议&#xff0c;本文不做任何论述&#xff0c;本文只论述bootloader如何使用串口通过Ymodem协议接收升级程序并进行IAP升级&#xff0c;以及bootloader和主程序两个工程的配置…
阅读更多...
UGUI Panel的显示和隐藏优化

UGUI Panel的显示和隐藏优化

unity UI如何开启&#xff08;显示&#xff09;或者关闭&#xff08;隐藏&#xff09;Panel界面&#xff0c;相信大家都是知道的&#xff0c;但是如何做最好呢&#xff1f; 可能大家一般开启/关闭界面的方法就是直接SetActive吧。这样做通常是可以的&#xff0c;简答快速地解决…
阅读更多...
多播ip地址配置和通信理解

多播ip地址配置和通信理解

经常有朋友问&#xff0c;为什么相同局域网的ip需要相同网段&#xff0c;为什么组播的网段可以不同&#xff1f; 比如&#xff1a; 在您的局域网&#xff08;192.168.1.0/24 网段&#xff09;中设置多播组时&#xff0c;您可以选择一个在本地网络范围内尚未使用的多播组地址。…
阅读更多...
【Java中序列化的原理是什么（解析）】

【Java中序列化的原理是什么（解析）】

&#x1f341;序列化的原理是什么&#xff1f; &#x1f341;典型-----解析&#x1f341;拓展知识仓&#x1f341;Serializable 和 Externalizable 接门有何不同? &#x1f341;如果序列化后的文件或者原始类被篡改&#xff0c;还能被反序列化吗?&#x1f341;serialVersionU…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023