• 【数据结构】线性表（五）跳表及其基本操作（定义、创建、查找、插入、删除）

    目录

    前言

    1. 单链表

    跳表（Skip List）

    0. 概念

    1. 数据结构

    a. 跳表节点结构SkipListNode

    b. 跳表结构SkipList

    2. 辅助函数

    a. 初始化节点

    b. 初始化跳表

    c. 生成随机层数

    3. 查找节点

    4. 插入节点

    5. 删除节点

    6. 主函数

    代码整合

    前言

    1. 单链表

            链表中的结点用存储单元（若干个连续字节）来存放，存储单元之间既可以是（存储空间上）连续的，也可以是不连续的，甚至可以零散地分布在存储空间中的任何位置。换言之，链表中结点的逻辑次序和物理次序之间并无必然联系。最重要的是，链表可以在不移动结点位置的前提下根据需要随时添加删除结点，动态调整。

    【数据结构】线性表（二）单链表及其基本操作（创建、插入、删除、修改、遍历打印）-CSDN博客icon-default.png?t=N7T8https://blog.csdn.net/m0_63834988/article/details/133914875

    数据结构_QomolangmaH的博客-CSDN博客icon-default.png?t=N7T8https://blog.csdn.net/m0_63834988/category_12435965.html

    跳表（Skip List）

    0. 概念

            增加了向前指针的链表叫作跳表。跳表全称叫做跳跃表，简称跳表。跳表是一个随机化的数据结构，实质就是一种可以进行二分查找的有序链表。跳表在原有的有序链表上面增加了多级索引，通过索引来实现快速查找。跳表不仅能提高搜索性能，同时也可以提高插入和删除操作的性能。

            跳表是一个随机化的数据结构，可以被看做二叉树的一个变种，它的性能在某些情况下可以与平衡二叉树（如红黑树和AVL树）相媲美，它的查找、插入和删除操作的时间复杂度为O(log n)

            跳表的原理相对简单，因此在一些具有内存限制或对插入和删除操作性能要求较高的场景下，跳表是一种常用的选择。例如，Redis和LevelDB等数据库系统中就广泛使用了跳表来实现有序集合的功能。

    1. 数据结构

    定义宏：

    #define MAX_LEVEL 6

    a. 跳表节点结构SkipListNode

    1. typedef struct SkipListNode {
    2.     int key;
    3.     int value;
    4.     struct SkipListNode** forward;
    5. } SkipListNode;

          SkipListNode表示跳表中的节点，包含一个整型的键值key和一个整型的值value，以及一个指向其他节点的指针数组forward

    b. 跳表结构SkipList

    1. typedef struct SkipList {
    2.     int max_level;
    3.     int level;
    4.     SkipListNode* header;
    5. } SkipList;

        SkipList表示整个跳表，包含最大层数max_level、当前层数level和一个指向头节点的指针header。

    2. 辅助函数

    a. 初始化节点

    1. SkipListNode* skipListNodeInit(int level, int key, int value) {
    2.     SkipListNode* node = (SkipListNode*)malloc(sizeof(SkipListNode));
    3.     node->key = key;
    4.     node->value = value;
    5.     node->forward = (SkipListNode**)malloc((level + 1) * sizeof(SkipListNode*));
    6.     for (int i = 0; i <= level; i++) {
    7.         node->forward[i] = NULL;
    8.     }
    9.     return node;
    10. }
    • 接受节点的层数level、键值key和值value作为参数，并动态分配内存来创建节点；
    • 将节点的键值和值设置为参数的值；
    • 为指针数组forward分配足够的内存；
    • 将指针数组中的所有元素初始化为NULL，并返回创建的节点。

    b. 初始化跳表

    1. SkipList* skipListInit() {
    2.     SkipList* skipList = (SkipList*)malloc(sizeof(SkipList));
    3.     skipList->max_level = MAX_LEVEL;
    4.     skipList->level = 0;
    5.     skipList->header = skipListNodeInit(MAX_LEVEL, 0, 0);
    6.     for (int i = 0; i <= MAX_LEVEL; i++) {
    7.         skipList->header->forward[i] = NULL;
    8.     }
    9.     return skipList;
    10. }
    • 动态分配内存来创建一个SkipList结构体
    • 设置最大层数max_level为预定义的常量值MAX_LEVEL
    • 设置当前层数level为0
    • 调用上述skipListNodeInit函数创建一个头节点。
    • 将头节点的指针数组中的所有元素初始化为NULL，并返回创建的跳表。

    c. 生成随机层数

    1. int randomLevel() {
    2.     int level = 1;
    3.     while (rand() < RAND_MAX / 2 && level < MAX_LEVEL) {
    4.         level++;
    5.     }
    6.     return level;
    7. }
    • 使用rand函数生成一个伪随机数，并与RAND_MAX的一半进行比较。如果生成的数小于RAND_MAX的一半，并且层数小于最大层数MAX_LEVEL，则层数加1。
    • 函数的目的是根据一定的概率生成一个合适的层数，用于插入节点时确定节点在每一层的高度。

    3. 查找节点

    1. SkipListNode* skipListSearch(SkipList* skipList, int key) {
    2.     SkipListNode* current = skipList->header;
    3.     for (int i = skipList->level; i >= 0; i--) {
    4.         while (current->forward[i] != NULL && current->forward[i]->key < key) {
    5.             current = current->forward[i];
    6.         }
    7.     }
    8.     current = current->forward[0];
    9.     if (current != NULL && current->key == key) {
    10.         return current;
    11.     } else {
    12.         return NULL;
    13.     }
    14. }

            从跳表的最高层开始遍历节点，找到在每一层中键值小于给定键值的最大节点。然后，沿着最底层的指针找到当前节点，并检查是否存在具有相同键值的节点。如果存在，返回该节点的指针。否则，返回NULL表示未找到。

    4. 插入节点

    1. void skipListInsert(SkipList* skipList, int key, int value) {
    2.     SkipListNode* update[MAX_LEVEL + 1];
    3.     SkipListNode* current = skipList->header;
    4.     for (int i = skipList->level; i >= 0; i--) {
    5.         while (current->forward[i] != NULL && current->forward[i]->key < key) {
    6.             current = current->forward[i];
    7.         }
    8.         update[i] = current;
    9.     }
    10.     current = current->forward[0];
    11.     if (current != NULL && current->key == key) {
    12.         current->value = value;
    13.     } else {
    14.         int new_level = randomLevel();
    15.         if (new_level > skipList->level) {
    16.             for (int i = skipList->level + 1; i <= new_level; i++) {
    17.                 update[i] = skipList->header;
    18.             }
    19.             skipList->level = new_level;
    20.         }
    21.         SkipListNode* new_node = skipListNodeInit(new_level, key, value);
    22.         for (int i = 0; i <= new_level; i++) {
    23.             new_node->forward[i] = update[i]->forward[i];
    24.             update[i]->forward[i] = new_node;
    25.         }
    26.     }
    27. }
    • 创建一个更新数组update，用于记录在每个层级上需要更新的节点
    • 从最高层级开始逐层遍历，找到要插入位置的前一个节点，并将其记录在更新数组中。
    • 通过比较当前节点的后继节点的键和要插入的键，确定新节点的插入位置，并更新前进节点数组。
      • 如果要插入的键已存在于跳表中，则更新对应的值。
      • 如果新节点的层级大于当前跳表的层级，需要更新跳表的层级，并更新对应层级的前进节点数组。最后，将新节点插入到跳表中。

    5. 删除节点

    1. void skipListDelete(SkipList* skipList, int key) {
    2.     SkipListNode* update[MAX_LEVEL + 1];
    3.     SkipListNode* current = skipList->header;
    4.     for (int i = skipList->level; i >= 0; i--) {
    5.         while (current->forward[i] != NULL && current->forward[i]->key < key) {
    6.             current = current->forward[i];
    7.         }
    8.         update[i] = current;
    9.     }
    10.     current = current->forward[0];
    11.     if (current != NULL && current->key == key) {
    12.         for (int i = 0; i <= skipList->level; i++) {
    13.             if (update[i]->forward[i] != current) {
    14.                 break;
    15.             }
    16.             update[i]->forward[i] = current->forward[i];
    17.         }
    18.         free(current);
    19.         while (skipList->level > 0 && skipList->header->forward[skipList->level] == NULL) {
    20.             skipList->level--;
    21.         }
    22.     }
    23. }
    • 创建一个更新数组update，用于记录在每个层级上需要更新的节点。
    • 从最高层级开始逐层遍历，找到要删除的节点的前一个节点，并将其记录在更新数组中。
    • 通过比较当前节点的后继节点的键和要删除的键，确定要删除的节点，并更新前进节点数组。
    • 释放要删除的节点的内存。
    • 检查跳表的当前层数，如果有必要，将当前层数减少，以确保跳表的高度与节点数量相匹配。

    6. 主函数

    1. int main() {
    2.     srand(time(NULL));
    3.     SkipList* skipList = skipListInit();
    4.  
    5.     skipListInsert(skipList, 3, 30);
    6.     skipListInsert(skipList, 1, 10);
    7.     skipListInsert(skipList, 2, 20);
    8.     skipListInsert(skipList, 4, 40);
    9.     skipListInsert(skipList, 6, 60);
    10.     skipListInsert(skipList, 5, 50);
    11.     skipListInsert(skipList, 7, 70);
    12.  
    13.     SkipListNode* node = skipListSearch(skipList, 4);
    14.     if (node != NULL) {
    15.         printf("Key: %d, Value: %d\n", node->key, node->value);
    16.     } else {
    17.         printf("Key not found.\n");
    18.     }
    19.  
    20.     skipListDelete(skipList, 4);
    21.  
    22.     node = skipListSearch(skipList, 4);
    23.     if (node != NULL) {
    24.         printf("Key: %d, Value: %d\n", node->key, node->value);
    25.     } else {
    26.         printf("Key not found.\n");
    27.     }
    28.  
    29.     return 0;
    30. }
    • 调用srand函数设置随机数种子
    • 通过调用skipListInit函数初始化一个跳表
    • 使用skipListInsert函数插入一系列键值对
    • 使用skipListSearch函数搜索具有键值为4的节点，并打印出节点的键值和值。
    • 使用skipListDelete函数删除具有键值为4的节点。
    • 再次使用skipListSearch函数搜索具有键值为4的节点，并打印出结果。

    代码整合

    1. #include 
    2. #include 
    3. #include 
    4.  
    5. #define MAX_LEVEL 6
    6.  
    7. typedef struct SkipListNode {
    8.     int key;
    9.     int value;
    10.     struct SkipListNode** forward;
    11. } SkipListNode;
    12.  
    13. typedef struct SkipList {
    14.     int max_level;
    15.     int level;
    16.     SkipListNode* header;
    17. } SkipList;
    18.  
    19. SkipListNode* skipListNodeInit(int level, int key, int value) {
    20.     SkipListNode* node = (SkipListNode*)malloc(sizeof(SkipListNode));
    21.     node->key = key;
    22.     node->value = value;
    23.     node->forward = (SkipListNode**)malloc((level + 1) * sizeof(SkipListNode*));
    24.     for (int i = 0; i <= level; i++) {
    25.         node->forward[i] = NULL;
    26.     }
    27.     return node;
    28. }
    29.  
    30. SkipList* skipListInit() {
    31.     SkipList* skipList = (SkipList*)malloc(sizeof(SkipList));
    32.     skipList->max_level = MAX_LEVEL;
    33.     skipList->level = 0;
    34.     skipList->header = skipListNodeInit(MAX_LEVEL, 0, 0);
    35.     for (int i = 0; i <= MAX_LEVEL; i++) {
    36.         skipList->header->forward[i] = NULL;
    37.     }
    38.     return skipList;
    39. }
    40.  
    41. int randomLevel() {
    42.     int level = 1;
    43.     while (rand() < RAND_MAX / 2 && level < MAX_LEVEL) {
    44.         level++;
    45.     }
    46.     return level;
    47. }
    48.  
    49. void skipListInsert(SkipList* skipList, int key, int value) {
    50.     SkipListNode* update[MAX_LEVEL + 1];
    51.     SkipListNode* current = skipList->header;
    52.     for (int i = skipList->level; i >= 0; i--) {
    53.         while (current->forward[i] != NULL && current->forward[i]->key < key) {
    54.             current = current->forward[i];
    55.         }
    56.         update[i] = current;
    57.     }
    58.     current = current->forward[0];
    59.     if (current != NULL && current->key == key) {
    60.         current->value = value;
    61.     } else {
    62.         int new_level = randomLevel();
    63.         if (new_level > skipList->level) {
    64.             for (int i = skipList->level + 1; i <= new_level; i++) {
    65.                 update[i] = skipList->header;
    66.             }
    67.             skipList->level = new_level;
    68.         }
    69.         SkipListNode* new_node = skipListNodeInit(new_level, key, value);
    70.         for (int i = 0; i <= new_level; i++) {
    71.             new_node->forward[i] = update[i]->forward[i];
    72.             update[i]->forward[i] = new_node;
    73.         }
    74.     }
    75. }
    76.  
    77. void skipListDelete(SkipList* skipList, int key) {
    78.     SkipListNode* update[MAX_LEVEL + 1];
    79.     SkipListNode* current = skipList->header;
    80.     for (int i = skipList->level; i >= 0; i--) {
    81.         while (current->forward[i] != NULL && current->forward[i]->key < key) {
    82.             current = current->forward[i];
    83.         }
    84.         update[i] = current;
    85.     }
    86.     current = current->forward[0];
    87.     if (current != NULL && current->key == key) {
    88.         for (int i = 0; i <= skipList->level; i++) {
    89.             if (update[i]->forward[i] != current) {
    90.                 break;
    91.             }
    92.             update[i]->forward[i] = current->forward[i];
    93.         }
    94.         free(current);
    95.         while (skipList->level > 0 && skipList->header->forward[skipList->level] == NULL) {
    96.             skipList->level--;
    97.         }
    98.     }
    99. }
    100.  
    101. SkipListNode* skipListSearch(SkipList* skipList, int key) {
    102.     SkipListNode* current = skipList->header;
    103.     for (int i = skipList->level; i >= 0; i--) {
    104.         while (current->forward[i] != NULL && current->forward[i]->key < key) {
    105.             current = current->forward[i];
    106.         }
    107.     }
    108.     current = current->forward[0];
    109.     if (current != NULL && current->key == key) {
    110.         return current;
    111.     } else {
    112.         return NULL;
    113.     }
    114. }
    115.  
    116. int main() {
    117.     srand(time(NULL));
    118.     SkipList* skipList = skipListInit();
    119.  
    120.     skipListInsert(skipList, 3, 30);
    121.     skipListInsert(skipList, 1, 10);
    122.     skipListInsert(skipList, 2, 20);
    123.     skipListInsert(skipList, 4, 40);
    124.     skipListInsert(skipList, 6, 60);
    125.     skipListInsert(skipList, 5, 50);
    126.     skipListInsert(skipList, 7, 70);
    127.  
    128.     SkipListNode* node = skipListSearch(skipList, 4);
    129.     if (node != NULL) {
    130.         printf("Key: %d, Value: %d\n", node->key, node->value);
    131.     } else {
    132.         printf("Key not found.\n");
    133.     }
    134.  
    135.     skipListDelete(skipList, 4);
    136.  
    137.     node = skipListSearch(skipList, 4);
    138.     if (node != NULL) {
    139.         printf("Key: %d, Value: %d\n", node->key, node->value);
    140.     } else {
    141.         printf("Key not found.\n");
    142.     }
    143.  
    144.     return 0;
    145. }

  • 相关阅读:
    计算机毕业设计ssm房源网4c6sv系统+程序+源码+lw+远程部署
    【前端笔记】SCSS学习篇之一：基础入门
    vivado xpm 使用和封装
    kubernetes(k8s)滚动发布，不宕机实战
    Gson 字符串常用转换方式（集合转换为Json数组
    MySQL-----事务管理
    每个人都应该去学写作
    LeetCode_704_二分查找
    0038__一文看懂NB-IOT/Lora/Zigbee三大技术的组网方式
    大模型应用疯狂加速，洗牌却在静悄悄进行了
  • 原文地址：https://blog.csdn.net/m0_63834988/article/details/133932672