C++跳表的实现

于 2024-12-21 11:05:41 发布
阅读量945 收藏 14
点赞数 26
文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_74626010/article/details/144627803
版权

一、跳表的介绍

        跳表(skiplist)和哈希表、平衡搜索树一样，也是一种查找结构。跳表多使用在 kv 型数据库中, Redis 中就会使用跳表

        平常有序的单链表，查找时间复杂度为O(N)。我们该如何考虑优化它呢？

        跳表中的思想就是将中间节点升高，直接和高层节点比较，大于它就向后，小于就向左，提高了查找效率。

一般的链表：

跳表：

        如果每一层的上层是下层的一半，那么就等同于二分查找。但是在插入和删除的过程中很难维护这个条件(如果要维护，时间复杂的很可能降回O(N) )。

        因此，跳表选择了随机层数，每一个节点的层数都是随机的。    

二、跳表的平均层数计算

​    假设跳表多增加一层的概率为 p，一层的概率为 (1-p)，二层的概率为 p*(1-p)，三层的概率为 p^2\*(1-p) ...... 由此类推，n 层的概率为 p^(n-1)*(1-p)

​    一个节点的平均层数：

     概率论知识：用概率乘以层数，相加，得到的就是层数的期望值。(可以反映随机变量平均取值大小)

由此可以得出，平均层数为 1/(1-p) 。

  • 当 p 为 0.5 时，平均层数为 2

  • 当 p 为 0.25 时，平均层数为 1.33 (redis 中 p 就选择为 0.25)

三、跳表的实现

1、跳表的结构设计

// 跳表节点
struct SkiplistNode
{
    int _val; // 该节点的值
    vector<SkiplistNode*> _nextV; // 下标+1 为层数，指向每一层的下一个节点

    SkiplistNode(int val, int level)
        :_val(val)
        , _nextV(level, nullptr)
    {}
};

class Skiplist {
public:
    typedef SkiplistNode node;
    
    Skiplist() 
    {
        // 初始化当前层数为 1
        _head = new node(-1, 1);
        srand(time(0)); // 随机数种子，新节点获取随机层数用的
    }
    
	node* _head; // 头结点
	double _p = 0.25; // 新增一层的概率
	int _maxLevel = 32; // 最大层数
};

在 Redis 实现的跳表中，两个参数取值为

p = 0.25

maxLevel = 32

2、获取随机层数

跳表多增加一层的概率为 p

// 给新节点一个随机层数
int GetLevel()
{
    // 开始为 1 层，每次 随机数/最大随机数 < p ，多加一层
    // 也就是多加一层的概率为 p，不能超过最大层
    int level = 1;
    while (rand() < _p * RAND_MAX && level < _maxLevel)
    {
        ++level;
    }

    return level;
}

3、跳表的查找

        跟cur->next[level]->val 比较，比他小或下一个为空，向下走；比他大，向右走。

        当走到层数 < 0，说明没找到该值。

bool search(int target) 
{
    node* cur = _head; // 当前节点
    int cur_level = _head->_nextV.size() - 1;// 当前节点层数

    // 如果层数 < 0，那么说明查找失败
    while (cur_level >= 0)
    {
        // 如果当前层的下一个为空，或者当前层的下一个比 target 大，向下层找
        if (cur->_nextV[cur_level] == nullptr 
            || cur->_nextV[cur_level]->_val > target)
            cur_level--;
        // 如果下一个节点比 target 小，向右查找
        else if (cur->_nextV[cur_level]->_val < target)
            cur = cur->_nextV[cur_level];
        else
            return true;
    }

    return false;
}

4、跳表的插入

        1、找到每一层的前一个节点

        2、逐层插入

// 查找值为 num 的前一个节点(每一层)
vector<node*> FindPrevNode(int num)
{
    // 拿到所有层的前一个节点，层数超过默认就为 head
    vector<node*> prevV(_maxLevel, _head);

    // 当前节点 与 当前节点层数
    node* cur = _head;
    int cur_level = _head->_nextV.size() - 1;

    // 当前层数 < 0 退出
    while (cur_level >= 0)
    {
        // 如果下一个为空 或 下一个大于 num，说明 cur 为 num 在当前层的前一个节点
        if (cur->_nextV[cur_level] == nullptr || cur->_nextV[cur_level]->_val >= num)
        {
            prevV[cur_level] = cur;
            cur_level--;
        }
        // 如果当前层下一个节点 < num，向右继续查找
        else if (cur->_nextV[cur_level]->_val < num)
            cur = cur->_nextV[cur_level];
    }

    return prevV;
}

void add(int num) {
    // 得到每一层的前节点集合
    vector<node*> prevV = FindPrevNode(num);

    // 得到一个随机层数，创建节点
    int newlevel = GetLevel();
    node* newnode = new node(num, newlevel);
    // 我们是用头结点的层数查找的
    // 如果头结点的层数 < 当前层数，更新头结点层数
    if (_head->_nextV.size() < newlevel)
        _head->_nextV.resize(newlevel);
    // 头结点 head 的新增层默认必须为空，新节点插入后才会指向空

    // 每一层插入
    for (int i = 0; i < newlevel; ++i)
    {
        newnode->_nextV[i] = prevV[i]->_nextV[i];
        prevV[i]->_nextV[i] = newnode;
    }
}

5、跳表的删除

        1、找到每一层的前一个节点

        2、逐层删除

bool erase(int num) 
{
    // 得到每一层的前节点集合，具体实现放在(4)插入中
    vector<node*> prevV = FindPrevNode(num);

    // 因为第一层是一定有的，因此用第一层做判断
    // 第一层前节点的下一个为空 或 值不为 num，说明没有值为 num 的节点，返回 false
    if (prevV[0]->_nextV[0] == nullptr || prevV[0]->_nextV[0]->_val != num)
        return false;

    node* del = prevV[0]->_nextV[0];// 要删除的节点
    int levelNum = del->_nextV.size();// 要删除的节点的层数

    // 遍历删除每一层
    for (int i = 0; i < levelNum; ++i)
    {
        prevV[i]->_nextV[i] = del->_nextV[i];
    }

    // 释放节点
    delete del;
    return true;
}

6、完整代码

struct SkiplistNode
{
    int _val;
    vector<SkiplistNode*> _nextV;

    SkiplistNode(int val, int level)
        :_val(val)
        , _nextV(level, nullptr)
    {}
};

class Skiplist {
public:
    typedef SkiplistNode node;
    Skiplist() {
        // 初始化当前层数为 1
        _head = new node(-1, 1);
        srand(time(0));
    }

    bool search(int target) 
    {
        node* cur = _head; // 当前节点
        int cur_level = _head->_nextV.size() - 1;// 当前节点层数

        // 如果层数 < 0，那么说明查找失败
        while (cur_level >= 0)
        {
            // 如果当前层的下一个为空，或者当前层的下一个比 target 大，向下层找
            if (cur->_nextV[cur_level] == nullptr || cur->_nextV[cur_level]->_val > target)
                cur_level--;
            // 如果下一个节点比 target 小，向右查找
            else if (cur->_nextV[cur_level]->_val < target)
                cur = cur->_nextV[cur_level];
            else
                return true;
        }

        return false;
    }

    // 查找值为 num 的前一个节点(每一层)
    vector<node*> FindPrevNode(int num)
    {
        // 拿到所有层的前一个节点，层数超过默认就为 head
        vector<node*> prevV(_maxLevel, _head);

        // 当前节点 与 当前节点层数
        node* cur = _head;
        int cur_level = _head->_nextV.size() - 1;

        // 当前层数 < 0 退出
        while (cur_level >= 0)
        {
            // 如果下一个为空 或 下一个大于 num，说明 cur 为 num 在当前层的前一个节点
            if (cur->_nextV[cur_level] == nullptr || cur->_nextV[cur_level]->_val >= num)
            {
                prevV[cur_level] = cur;
                cur_level--;
            }
            // 如果当前层下一个节点 < num，向右继续查找
            else if (cur->_nextV[cur_level]->_val < num)
                cur = cur->_nextV[cur_level];
        }

        return prevV;
    }

    void add(int num) {
        // 得到每一层的前节点集合
        vector<node*> prevV = FindPrevNode(num);

        // 得到一个随机层数，创建节点
        int newlevel = GetLevel();
        node* newnode = new node(num, newlevel);
        // 我们是用头结点的层数查找的
        // 如果头结点的层数 < 当前层数，更新头结点层数
        if (_head->_nextV.size() < newlevel)
            _head->_nextV.resize(newlevel);

        // 每一层插入
        for (int i = 0; i < newlevel; ++i)
        {
            newnode->_nextV[i] = prevV[i]->_nextV[i];
            prevV[i]->_nextV[i] = newnode;
        }
    }

    bool erase(int num) {
        // 得到每一层的前节点集合
        vector<node*> prevV = FindPrevNode(num);

        // 因为第一层是一定有的，因此用第一层做判断
        // 第一层前节点的下一个为空 或 值不为 num，说明没有值为 num 的节点，返回 false
        if (prevV[0]->_nextV[0] == nullptr || prevV[0]->_nextV[0]->_val != num)
            return false;

        node* del = prevV[0]->_nextV[0];// 要删除的节点
        int levelNum = del->_nextV.size();// 要删除的节点的层数

        // 遍历删除每一层
        for (int i = 0; i < levelNum; ++i)
        {
            prevV[i]->_nextV[i] = del->_nextV[i];
        }

        // 释放节点
        delete del;
        return true;
    }

    // 给新节点一个随机层数
    int GetLevel()
    {
        // 开始为 1 层，每次 随机数/最大随机数 < p ，多加一层
        // 也就是多加一层的概率为 p，不能超过最大层
        int level = 1;
        while (rand() < _p * RAND_MAX && level < _maxLevel)
        {
            ++level;
        }

        return level;
    }

    void Print()
    {
        int level = _head->_nextV.size();
        
        for (int i = level - 1; i >= 0; --i)
        {
            node* cur = _head->_nextV[i];
            while (cur)
            {
                printf("%d -> ", cur->_val);
                cur = cur->_nextV[i];
            }
            printf("\n");
        }
    }

    node* _head;
    double _p = 0.25;
    int _maxLevel = 32;
};

四、跳表的自测

        可以根据题目来测试实现的跳表是否正确哦：跳表测试题[]~(￣▽￣)~*

跳表的C++实现
Castria的博客
11-07 2803
跳表(Skip List)是在链表基础上进行改进的一种有序的数据结构，它为了便于查找，在插入过程中随机地将一些元素提升为高度为1~r的索引，以此来加快之后的操作。索引可以分为多层，一般而言，层数越高的索引个数越少。下面的图是一个跳表示例（隐去表头，上面的为高层） 为了方便下面对代码实现的说明，先给出各数据类型的定义。 template<typename T> class skiplist { private: static constexpr int MAX_LEVEL = 16; s
C++实现跳表
mmz123_的博客
09-12 1133
跳表
跳跃表 C++实现
11-23
跳跃表的C++实现版本。 提供与红黑树的测试用例。
跳表C++实现
最新发布
jiujiederoushan的博客
11-18 278
跳跃链表
C++面试：跳表
Bobowen的博客
01-22 1342
跳表中的每个节点都包含一个元素，并且节点按照元素的大小有序排列。跳表通过维护多层索引来实现快速搜索。每一层都是一个有序链表，最底层包含所有元素，而每上一层的节点是下一层节点的一部分。通过索引层，跳表允许在较高层直接跳过一些节点，从而提高搜索效率。特性:跳表中的每个节点按照元素的大小有序排列，使得在跳表中可以快速定位和搜索元素。跳表通过维护多层索引来实现快速搜索，每一层都是一个有序链表，最底层包含所有元素。通过多层索引，跳表允许在较高层直接跳过一些节点，实现跳跃式的访问，提高搜索效率。
C++跳表实现
qq_34988341的博客
07-18 468
#pragma once #ifndef __SKIPLIST__H #define __SKIPLIST__H #include "skipNode.h" #include <vector> #include <math.h> #include <sstream> #include "dictionary.h" #include "illegalValue.h" /* * * * []------------->[]-------------
skiplist数据结构简介
chuixieli7527的博客
10-03 505
skiplist数据结构简介 skiplist本质上也是一种查找结构，用于解决算法中的查找问题（Searching），即根据给定的key，快速查到它所在的位置（或者对应的value）。 一般查找问题的解法分为两个大类：一个是基于各种平衡树，一个是基于哈希表。但skiplist却比较特殊，它没法...
跳表 （Skip List） C++ 实现
木牛的博客
05-24 1084
跳表 （Skip List） C++ 实现 跳表原理 跳表 c++ 实现 SkipNode SkipList 随机层数 结点最大层数 基本操作 打印 主函数 输出结果 在学习 C++ 中的过程中，找个算法作为练习。 仅供参考。 跳表原理 跳表原理讲解请参考 https://lotabout.me/2018/skip-list/ 为了节约时间，这里只是简单说明，原文如上。 跳表(skip list) 对标的是平衡树(AVL Tree)，是一种 插入/删除/搜索 都是 O ( l o g n ) O
skiplist 跳表C++实现
10-08
skiplist 跳表C++实现,资料参考 en.wikipedia.org/wiki/Skip_list
skiplist跳表C++实现
03-04
skiplist的C++实现，包含test程序
C++跳表实现轻型键值数据库源码及项目说明
资源摘要信息:"C++课程作业基于跳表实现的轻型键值型数据库源码+项目说明.zip" 该项目是一个C++课程作业，主要目标是实现一个基于跳表（Skip List）的数据结构的轻型键值型数据库。跳表是一种可以通过多层链表来...
探索C++跳表实现的键值存储引擎技术
资源摘要信息:"C++实现基于跳表实现的轻量级键值型存储引擎" 知识点概述: 1. C++语言特性: C++是一种多范式的编程语言，它继承了C语言的特性，同时引入了面向对象的特性，包括类、继承、多态、封装等。它支持过程化...
数据结构：跳表实现(C++)
li209779的博客
11-06 914
本文使用C++实现跳表的增删查。铁蕾大佬关于跳表的博客以上就是跳表的实现。
c++实现跳跃表
得也一天，失也一天！
02-20 865
直接上代码，拷贝过去就能运行 注释写在对应的代码里、 节点的定义 #ifndef _SKIP_NODE_H #define _SKIP_NODE_H #include <iostream> struct skipNode { int key; int value; int level; //size表示该节点存在的最高层数 skipNode* *next; //skipNo...
跳表数据结构的C++实现
gaixm的专栏
01-28 547
1、背景 有序链表是一种常用的数据结构，具备链表的优点，不会占用较大的连续内存并且可以实现快速插入，适合频繁插入、更新的应用场景。但是随着节点数目的增多，O(n)的查询复杂度使得性能下降。为了优化查询性能，在原有的数据链表基础上，增加一层至多层逻辑链表，这样的数据结构就成为跳表，可以大大加速有序链表的查询性能。 2、代码实现 #include <iostream> #include <string> #include <vector> #include..
C++【跳表】
芊樱烛渊的博客
12-29 1525
skiplist本质上也是一种查找结构，用于解决算法中的查找问题，跟平衡搜索树和哈希表的价值是一样的，可以作为key或者key/value的查找模型。skiplist是由William Pugh发明的，最早出现于他在1990年发表的论文《Skip Lists: A对细节感兴趣的同学可以下载论文原文来阅读。skiplist，顾名思义，首先它是一个list。实际上，它是在有序链表的基础上发展起来的。如果是一个有序的链表，查找数据的时间复杂度是O(N)。假如我们每相邻两个节点升高一层，增加一个指针。
跳表c++实现
weixin_44866921的博客
10-07 592
原理：https://blog.youkuaiyun.com/u013011841/article/details/39158585 一.跳表结构 1.节点 //节点 class node { int val; int level;//节点的高度(层次) node* forword[MAXLEVEL];//指向node*的数组 }; 2.skiplist（管理整个表的一个数据结构） class skiplist { private: node* head;//指向跳表的头结点 int max_length
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值