skip list

无标题
#include <iostream>
#include <cstdlib>
#include <cstdint>
#include <cstring>
#include <ctime>#define SKIP_LIST_MAX_LEVEL 4// 跳表连接item
typedef struct skip_list_item
{struct skip_list_node *prev; // 上一个节点指针，指向头，&head[0]/headstruct skip_list_node *next; // 下一个节点指针
} skip_list_item_t;// 跳表节点
typedef struct skip_list_node
{skip_list_item_t item[SKIP_LIST_MAX_LEVEL]; // 跳表节点itemuint32_t key;                                // 用于排序的keyuint32_t level;                              // 节点当前所在层级
} skip_list_node_t;// 跳表结构
typedef struct skip_list
{skip_list_node_t head;  // 跳表每层的head，head.item[0]为原表uint64_t size;          // 跳表节点总数uint32_t level;         // 下次节点插入跳表层数uint32_t level_max;     // 跳表最大层数
} skip_list_t;/*******************************************************************************/
skip_list_t *skip_list_create()
{skip_list_t *skip_list = (skip_list_t *)calloc(1, sizeof(skip_list_t));skip_list->size = 0;skip_list->level = 0;skip_list->level_max = SKIP_LIST_MAX_LEVEL;return skip_list;
}void skip_list_destroy(skip_list_t *skip_list)
{skip_list_node_t *node = skip_list->head.item[0].next;while (node != NULL){skip_list_node_t *next = node->item[0].next;free(node);node = next;}free(skip_list);
}void skip_list_node_init(skip_list_node_t *node, uint32_t key, uint32_t level)
{memset(&node->item, 0, sizeof(node->item));node->key = key;node->level = level;
}void skip_list_update_level(skip_list_t *skip_list)
{uint32_t level = 1;while ((rand() & 65535) < 32768){level++;}level = level < SKIP_LIST_MAX_LEVEL ? level : SKIP_LIST_MAX_LEVEL;skip_list->level = level - 1;
}void skip_list_insert(skip_list_t *skip_list, skip_list_node_t *node)
{skip_list_update_level(skip_list);node->level = skip_list->level;skip_list_node_t *update[SKIP_LIST_MAX_LEVEL];skip_list_node_t *x = &skip_list->head;int i = SKIP_LIST_MAX_LEVEL - 1;// 找到每一层要插入的位置while (i >= 0){while (x->item[i].next != NULL && x->item[i].next->key < node->key){x = x->item[i].next;}update[i] = x;i--;}// 执行插入操作for (int i = 0; i <= (int)node->level; i++){node->item[i].next = update[i]->item[i].next;if (update[i]->item[i].next != NULL){update[i]->item[i].next->item[i].prev = node;}update[i]->item[i].next = node;node->item[i].prev = update[i];}skip_list->size++;
}skip_list_node_t *skip_list_find(skip_list_t *skip_list, uint32_t key)
{if (skip_list->size == 0)return NULL; // 空表skip_list_node_t *x = &skip_list->head;int i = SKIP_LIST_MAX_LEVEL - 1;// 先找到节点while (i >= 0){while (x->item[i].next != NULL && x->item[i].next->key < key){x = x->item[i].next;}i--;}x = x->item[0].next;if (x != NULL && x->key == key){return x;}return NULL;
}skip_list_node_t *skip_list_find_max(skip_list_t *skip_list)
{if (skip_list->size == 0)return NULL; // 空表skip_list_node_t *x = &skip_list->head;int i = SKIP_LIST_MAX_LEVEL - 1;// 找到最大节点while (i >= 0){while (x->item[i].next != NULL){x = x->item[i].next;}i--;}if (x == &skip_list->head)return NULL;return x;
}skip_list_node_t *skip_list_find_min(skip_list_t *skip_list)
{if (skip_list->size == 0)return NULL; // 空表skip_list_node_t *x = skip_list->head.item[0].next;if (x == NULL)return NULL;return x;
}void skip_list_print(skip_list_t *skip_list)
{for (int i = SKIP_LIST_MAX_LEVEL - 1; i >= 0; i--){skip_list_node_t *x = skip_list->head.item[i].next;std::cout << "Level " << i << ": ";while (x != NULL){std::cout << x->key << " ";x = x->item[i].next;}std::cout << std::endl;}
}int main()
{skip_list_t *skip_list = skip_list_create();srand(time(NULL));uint32_t keys[] = {3, 6, 7, 9, 12, 19, 17, 26, 21, 25};for (uint32_t key : keys){skip_list_node_t *node = (skip_list_node_t *)malloc(sizeof(skip_list_node_t));skip_list_node_init(node, key, 0);skip_list_insert(skip_list, node);}std::cout << "Skip List:" << std::endl;skip_list_print(skip_list);uint32_t search_key = 19;skip_list_node_t *found = skip_list_find(skip_list, search_key);std::cout << "Search for " << search_key << ": " << (found ? "Found" : "Not Found") << std::endl;search_key = 15;found = skip_list_find(skip_list, search_key);std::cout << "Search for " << search_key << ": " << (found ? "Found" : "Not Found") << std::endl;skip_list_destroy(skip_list);return 0;
}

skip_list_insert 函数流程

随机决定新节点的层数

void skip_list_insert(skip_list_t *skip_list, skip_list_node_t *node)
{skip_list_update_level(skip_list);  // 随机更新跳表的层数node->level = skip_list->level;     // 设置新节点的层数
}

skip_list_update_level(skip_list) 会随机决定新节点需要占据的层数（根据概率，高层节点少，低层节点多，类似于抛硬币）。
新节点 node 的层数被设置为刚刚生成的随机层数 skip_list->level。

找到每一层要插入的位置

skip_list_node_t *update[SKIP_LIST_MAX_LEVEL];  // 保存插入位置的前驱节点
skip_list_node_t *x = &skip_list->head;         // 从跳表的头节点开始
int i = SKIP_LIST_MAX_LEVEL - 1;// 找到每一层要插入的位置
while (i >= 0)
{while (x->item[i].next != NULL && x->item[i].next->key < node->key){x = x->item[i].next;  // 在第 i 层向右移动，寻找插入位置}update[i] = x;  // 记录需要在第 i 层插入的位置的前一个节点i--;  // 进入下一层
}skip_list_node_t *update[SKIP_LIST_MAX_LEVEL];  // 保存插入位置的前驱节点
skip_list_node_t *x = &skip_list->head;         // 从跳表的头节点开始
int i = SKIP_LIST_MAX_LEVEL - 1;// 找到每一层要插入的位置
while (i >= 0)
{while (x->item[i].next != NULL && x->item[i].next->key < node->key){x = x->item[i].next;  // 在第 i 层向右移动，寻找插入位置}update[i] = x;  // 记录需要在第 i 层插入的位置的前一个节点i--;  // 进入下一层
}

​
初始化了一个 update 数组，用于保存插入位置前驱节点。
设置一个指针 x 指向跳表的头节点，从最高层 (i = SKIP_LIST_MAX_LEVEL - 1) 开始。
通过内层循环，在每一层查找当前节点 x 所需插入位置的前一个节点，并将该节点记录到 update 数组。
如果 x->item[i].next 不为空且 x->item[i].next->key 小于 node->key，则 x 继续向右移动。
一旦找到适合插入位置的节点，记录在 update[i] 中。
逐层向下（i–）重复上述步骤，直到最低层（层0）。
3. 执行插入操作
// 执行插入操作
for (int i = 0; i <= (int)node->level; i++)
{
node->item[i].next = update[i]->item[i].next; // 新节点的 next 指向前驱节点的 next
if (update[i]->item[i].next != NULL)
{
update[i]->item[i].next->item[i].prev = node; // 前驱节点的 next 指向新节点
}
update[i]->item[i].next = node; // 前驱节点的 next 指向新节点
node->item[i].prev = update[i]; // 新节点的 prev 指向前驱节点
}

skip_list->size++;  // 更新跳表中的节点数

}
复制
// 执行插入操作
for (int i = 0; i <= (int)node->level; i++)
{
node->item[i].next = update[i]->item[i].next; // 新节点的 next 指向前驱节点的 next
if (update[i]->item[i].next != NULL)
{
update[i]->item[i].next->item[i].prev = node; // 前驱节点的 next 指向新节点
}
update[i]->item[i].next = node; // 前驱节点的 next 指向新节点
node->item[i].prev = update[i]; // 新节点的 prev 指向前驱节点
}

skip_list->size++;  // 更新跳表中的节点数

}
​
遍历从第0层到新节点的最大层 node->level：
node->item[i].next = update[i]->item[i].next;：新节点 node 的下一个节点指向更新节点 update[i] 的下一个节点。
if (update[i]->item[i].next != NULL)：如果 update[i]->item[i].next 不是空，则更新下一个节点的 prev 指针指向新节点 node。
update[i]->item[i].next = node;：更新节点 update[i] 的下一个节点指向新节点 node。
node->item[i].prev = update[i];：新节点 node 的前一个节点指向更新节点 update[i]。
最后，更新跳表的节点总数 skip_list->size++。
插入过程示意图
假设跳表如下，准备插入节点 node（key为10）：

当前跳表：
Level 3: head -> 15 -> NULL
Level 2: head -> 9 -> 15 -> NULL
Level 1: head -> 7 -> 9 -> 15 -> NULL
Level 0: head -> 3 -> 7 -> 9 -> 15 -> NULL
复制
当前跳表：
Level 3: head -> 15 -> NULL
Level 2: head -> 9 -> 15 -> NULL
Level 1: head -> 7 -> 9 -> 15 -> NULL
Level 0: head -> 3 -> 7 -> 9 -> 15 -> NULL
​

  1. 查找插入位置：
    在每一层中找到应插入位置前的节点。

update[] = { head, 7, 9, 9 };
复制
update[] = { head, 7, 9, 9 };
​
2. 执行插入：
假设新节点随机生成的层数为2（第三层也有节点）。

把新节点插入适当位置后：

插入 key=10 后的跳表：
Level 3: head -> 10 -> 15 -> NULL
Level 2: head -> 9 -> 10 -> 15 -> NULL
Level 1: head -> 7 -> 9 -> 10 -> 15 -> NULL
Level 0: head -> 3 -> 7 -> 9 -> 10 -> 15 -> NULL
复制
插入 key=10 后的跳表：
Level 3: head -> 10 -> 15 -> NULL
Level 2: head -> 9 -> 10 -> 15 -> NULL
Level 1: head -> 7 -> 9 -> 10 -> 15 -> NULL
Level 0: head -> 3 -> 7 -> 9 -> 10 -> 15 -> NULL

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

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

相关文章

群晖NAS使用Docker本地部署网页版Ubuntu系统并实现无公网IP远程访问

群晖NAS使用Docker本地部署网页版Ubuntu系统并实现无公网IP远程访问

文章目录 前言1. 下载Docker-Webtop镜像2. 运行Docker-Webtop镜像3. 本地访问网页版Linux系统4. 群晖NAS安装Cpolar工具5. 配置异地访问Linux系统6. 异地远程访问Linux系统7. 固定异地访问的公网地址 前言 本文旨在详细介绍如何在群晖NAS部署docker-webtop&#xff0c;并结合c…
阅读更多...
电力电塔电线缺陷检测数据集 voc yolo

电力电塔电线缺陷检测数据集 voc yolo

电力 电塔电线缺陷检测数据集 10000张 带标注 voc yolo 电力电塔电线缺陷检测数据集 数据集描述 该数据集旨在用于电力电塔和电线的缺陷检测任务&#xff0c;涵盖多种常见的缺陷类型。数据集包含了大量的图像及其对应的标注信息&#xff0c;可用于训练计算机视觉模型&#x…
阅读更多...
c++运行.h和.cpp格式代码_windows

c++运行.h和.cpp格式代码_windows

1、main.cpp 一个主程序文件&#xff0c;这是主程序文件&#xff0c;调用了 TestClass 类中的方法。 #include "TestClass.h" #include <iostream>int main() {TestClass testObj; // 创建TestClass类的对象testObj.printMessage(); // 调用类的方法std::co…
阅读更多...
Linux：进程（一）

Linux：进程（一）

目录 一、概念的理解 二、指令操作 一、概念的理解 在许多地方对进程的定义都是这样的一句话&#xff1a;加载到内存中的程序、正在运行的程序、进程可以排队 而要真正理解进程是什么&#xff0c;这一句话的解释远远不够。 在定义进程之前&#xff0c;先来理解程序&#xff0…
阅读更多...
21、Tomato

21、Tomato

难度 低(个人认为中) 目标 root权限 一个flag 使用VMware启动 kali 192.168.152.56 靶机 192.168.152.66 信息收集 端口信息收集 可以看到有个ftp服务&#xff0c;2211实际是ssh协议端口&#xff0c;80、8888是一个web服务 web测试 80端口显示一个tomato 查看源码给了一些…
阅读更多...
网关过滤器（Gateway Filter）

网关过滤器（Gateway Filter）

网关过滤器&#xff08;Gateway Filter&#xff09;是在微服务架构中&#xff0c;特别是在使用Spring Cloud Gateway等API网关时&#xff0c;用于拦截并处理进出网络请求的重要组件。它们允许开发者在请求被路由到目标服务之前或响应被返回给客户端之后&#xff0c;对请求和响应…
阅读更多...
MATLAB系列06：复数数据、字符数据和附加画图类

MATLAB系列06：复数数据、字符数据和附加画图类

MATLAB系列06&#xff1a;复数数据、字符数据和附加画图类 6. 复数数据、字符数据和附加画图类6.1 复数数据6.1.1 复变量&#xff08; complex variables&#xff09;6.1.2 带有关系运算符的复数的应用6.1.3 复函数&#xff08; complex function&#xff09;6.1.4 复数数据的作…
阅读更多...
expressjs 如何封装接口响应数据

expressjs 如何封装接口响应数据

在 Express.js 中封装接口响应数据是一个常见的需求，它有助于保持 API 响应的一致性、易于维护和调试。封装响应数据通常涉及创建一个或多个中间件或工具函数，这些函数可以处理诸如设置状态码、构造响应体、添加通用头部等任务。 以下是一个简单的示例，展示了如何在 Expres…
阅读更多...
QUIC 和 HTTP/3：提升网络性能的关键技术

QUIC 和 HTTP/3：提升网络性能的关键技术

一、引言 1.1 简要介绍 QUIC 和 HTTP/3 QUIC&#xff08;Quick UDP Internet Connections&#xff09;是一种基于 UDP 的传输层协议&#xff0c;旨在解决 TCP 在高延迟和丢包环境下的性能问题。HTTP/3 则是 HTTP 协议的最新版本&#xff0c;它基于 QUIC 协议而非 TCP&#xf…
阅读更多...
【笔记】时间复杂度

【笔记】时间复杂度

文章目录 时间复杂度概念常见的时间复杂度时间复杂度的衡量常数时间例子线性时间例子平方时间例子对数时间例子 时间复杂度概念 时间复杂度&#xff1a;衡量算法随着输入量增长&#xff0c;执行时间的增长速度。 一般来说&#xff0c;肯定是希望时间复杂度小点比较好。 常见…
阅读更多...
linux文件同步、传输

linux文件同步、传输

使用rsync 适合用于大量文件多次同步&#xff0c;此工具是增量的同步&#xff0c;即如果之前同步过一次了&#xff0c;后续再同步&#xff0c;他只会传输有变化、新增的文件&#xff0c;就是之前同步过的文件如果没有变化&#xff08;文件大小、修改时间等判断&#xff09;就不…
阅读更多...
Python使用虚拟环境解决依赖冲突

Python使用虚拟环境解决依赖冲突

在处理多个 Python 库依赖时&#xff0c;遇到依赖冲突是很常见的&#xff0c;特别是当项目依赖的库版本相互不兼容时。要解决这些冲突&#xff0c;可以采用以下方式。 1. 虚拟环境的使用 为了避免系统级和用户级包的冲突&#xff0c;建议你使用 虚拟环境。虚拟环境为每个项目…
阅读更多...
【FPGA】编程方式

【FPGA】编程方式

FPGA编程方式 1 什么是PLD&#xff1f;2 什么是颗粒度&#xff1f;3 可编程逻辑器件的编程方式有哪些&#xff1f;3.1 SRAM 编程技术3.2 Flash/EEPROM 编程技术3.3 反熔丝编程技术3.4 编程技术比较 参考资料 1 什么是PLD&#xff1f; 可编程逻辑器件 英文全称为&#xff1a;pr…
阅读更多...
SpringBoot 数据库表结构文档生成

SpringBoot 数据库表结构文档生成

官方地址&#xff1a;https://github.com/pingfangushi/screw screw 螺丝钉&#xff0c;支持以下数据库 MySQL MariaDB TIDB Oracle SqlServer PostgreSQL Cache DB&#xff08;2016&#xff09; 生产文档支持 html word markdown 开始 添加依赖 <!-- 螺丝钉 --><…
阅读更多...
【Kubernetes】常见面试题汇总（二十九）

【Kubernetes】常见面试题汇总（二十九）

目录 81.简述你知道的几种 CNI 网络插件&#xff0c;并详述其工作原理。K8s 常用的CNI网络插件&#xff08;calico && flannel&#xff09;&#xff0c;简述一下它们的工作原理和区别。 特别说明&#xff1a; 题目 1-68 属于【Kubernetes】的常规概念题&#xff…
阅读更多...
c语言面试字符串复制

c语言面试字符串复制

1&#xff0c;下面这个函数的打印是什么&#xff1a; #include<stdio.h> #include<string.h>int main() {char str0[5], str1[] "welcome";strcpy(str0, str1);printf("str0:%s\r\n",str0);printf("str1:%s\r\n",str1); } larkla…
阅读更多...
nginx实现https安全访问的详细配置过程

nginx实现https安全访问的详细配置过程

文章目录 前言什么是 HTTP&#xff1f;什么是 HTTPS&#xff1f;HTTP 和 HTTPS 的区别为什么 HTTPS 被称为安全的&#xff1f;配置过程配置自签名证书 前言 首先我们来简单了解一下什么是http和https以及他们的区别所在. 什么是 HTTP&#xff1f; HTTP&#xff0c;全称为“超…
阅读更多...
Apache Iceberg 试用

Apache Iceberg 试用

启动 spark-sql 因为 iceberg 相关的 jars 已经在 ${SPARK_HOME}/jars 目录&#xff0c;所以不用 --jars 或者 --package 参数。 spark-sql --master local[1] \--conf spark.sql.extensionsorg.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions \--conf spar…
阅读更多...
notepad++的json查看

notepad++的json查看

json文件查看 因为接触到3dtile模型&#xff0c;所以经常需要和json打交道&#xff0c;但是很多模型是下面这种情况&#xff0c;不好阅读&#xff0c;所以可以使用notepad的插件查看 正常打开是这样的 加载notepad插件 搜索json下载安装就可以了 如果网络抽象&#xff0c;下载…
阅读更多...
Hive企业级调优[3]—— Explain 查看执行计划

Hive企业级调优[3]—— Explain 查看执行计划

Explain 查看执行计划 Explain 执行计划概述 EXPLAIN 命令呈现的执行计划由一系列 Stage 组成。这些 Stage 之间存在依赖关系&#xff0c;每一个 Stage 可能对应一个 MapReduce Job 或者一个文件系统的操作等。如果某 Stage 对应了一个 MapReduce Job&#xff0c;则该 Job 在 …
阅读更多...
最新文章

Copyright @ 2022~2023