skiplist-cpp

置顶 已于 2023-03-07 19:48:32 修改
阅读量293 收藏 1
点赞数 1
文章标签： skiplist 算法 数据结构
于 2023-02-24 21:41:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45045804/article/details/129208028
版权

0. 优化空间

  1. 增加Score权值
  2. 使用了 C++11 智能指针，实现了自动管理动态分配的内存
  3. 每次创建节点时，是随机生成层数，改为根据幂次定律（越大的数出现的概率越小）随机生成层数
  4. 增加异步日志系统。

1. Node类

1.1 定义

Node类中有以下几个成员函数

  1. Key and Value
  2. node_level：当前节点的层数
  3. forward：每个节点的forward成员函数是一个指向Node的指针数组，作用：Node_A->forward[x]保存的是当前节点A的第x层的下一个Node指针。
template<typename K, typename V> 
class Node {
// ~ Node 节点定义
public:

    Node() {}            //  默认构造函数

    Node(K k, V v, int); // 有参构造函数

    ~Node();             // 析构函数

    K get_key() const;   // 取 Key

    V get_value() const; // 取 value

    void set_value(V);   // 设定 value

    // 前向指针数组，对于不同的层，可能指向不同节点
    Node<K, V> **forward; // 前向指针数组,内部存放前向指针，指向下一个 Node

    int node_level;      // 节点层数

private:
    K key;
    V value;
};

1.2 构造函数

Node类的构造函数主要负责：

  1. 给出Key and Value， level。
  2. 根据level，初始化forward指针数组。
//构造函数
template<typename K, typename V> 
Node<K, V>::Node(const K k, const V v, int level) {
    this->key = k;
    this->value = v;
    this->node_level = level; 

    // level + 1, because array index is from 0 - level
    this->forward = new Node<K, V>*[level+1];//创建一个保存Node*的数组，长度为level+1
    
	// 初始化
    memset(this->forward, 0, sizeof(Node<K, V>*)*(level+1));
};

//析构函数
template<typename K, typename V> 
Node<K, V>::~Node() {
    delete []forward;
};

2. SkipList类

1.1 定义

SkipList类代表的是整个跳表，类中有个最重要的元素：_header：一个指向Node节点的指针，为头节点指针。

SkipList负责跳表的增删改查、落盘工作
所提供的接口 ：

  • insert_element 插入数据
  • delete_element 删除数据
  • search_element 查询数据
  • update_element 更新数据
  • display_list 打印跳跃表
  • dump_file 数据落盘
  • load_file 加载数据
  • size 返回数据规模
  • clear 清空跳表（新加）
template <typename K, typename V> 
class SkipList {

public:
    // 构造和析构函数，创建 Node 节点函数
    SkipList(int);
    ~SkipList();
    Node<K, V>* create_node(K, V, int);

    //获得随即层高
    int get_random_level();

    int insert_element(K, V);//增
    bool search_element(K);//查
    void delete_element(K);//删

    void display_list();//打印跳表

    // 数据落盘和数据加载
    void dump_file();
    void load_file();

    int size();

private:
    // 数据加载相关函数, 用来区分 key 和 value
    void get_key_value_from_string(const std::string& str, std::string* key, std::string* value);
    bool is_valid_string(const std::string& str);

private:
    int _max_level;  	   // 跳表层数上限
    int _skip_list_level;  // 当前跳表的最高层
    int _element_count;    // 跳表中节点数
    Node<K, V> *_header;   // 跳表中头节点指针


    // file operator
    std::ofstream _file_writer;
    std::ifstream _file_reader;

};

1.2 构造函数、析构函数、创建节点函数

构造函数负责：

  1. 给出整个跳表所允许的最大层数
  2. 创建一个头节点，头节点的层数为所允许的最大层数。（头节点不保存数据）
template<typename K, typename V> 
SkipList<K, V>::SkipList(int max_level) {

    this->_max_level = max_level;
    this->_skip_list_level = 0;
    this->_element_count = 0;

    // create header node and initialize key and value to null
    K k;
    V v;
    this->_header = new Node<K, V>(k, v, _max_level);
};

析构函数负责：内存回收(注意：原项目中没有释放内存)

template<typename K, typename V> 
SkipList<K, V>::~SkipList() {

    if (_file_writer.is_open()) {
        _file_writer.close();
    }
    if (_file_reader.is_open()) {
        _file_reader.close();
    }
    delete _header;
}

创建新的节点用到Node类的构造函数

template<typename K, typename V>
Node<K, V>* SkipList<K, V>::create_node(const K k, const V v, int level) {
    Node<K, V> *n = new Node<K, V>(k, v, level);
    return n;
}

1. 3 insert_element()----插入

插入数据：将数据插入跳表中，并为其随机生成层数
插入数据的整体步骤：

  1. 先加锁。
  2. 使用一个指向Node的指针current来负责遍历整个跳表。
  3. 初始化一个指向Node的指针数组update，作用：update[x]保存的是第x层最后一个符合要求的节点。要求：只要当前节点的下一节点非空，且 key 小于目标。
  4. 用current从那个最高层开始遍历，保存每一层的Node指针到update数组中
  5. 判断所插入的元素是否存在在表中，如果存在则返回1，插入失败；
  6. 如果不存在：开始为该节inserted_node点生成随机层数level。
  7. 如果新添加的节点层高level大于当前跳表层高，则需要更新 update 数组，将原本[_skip_list_level, random_level]范围内的NULL改为_header，
  8. 得到最终确定的层高后，就可以创建节点，挨层进行插入：根据刚刚所保存的update数组，将该节点的forward[i]=update->forward[i]，update->forward[i]=inserted_node。
    注意：每个节点的forward成员函数是一个指向Node的指针数组，作用：Node_A->forward[x]保存的是当前节点A的第x层的下一个Node指针。
template<typename K, typename V>
int SkipList<K, V>::insert_element(const K key, const V value) {
    mtx.lock(); // 写操作，加锁
    Node<K, V> *current = this->_header; // 从头节点遍历

    // update 是一个指针数组，数组内存放指针，指向 node 节点，其索引代表的是层数。
    // update[x]保存的是第x层最后一个符合要求的节点（要求：只要当前节点的下一节点非空，且 key 小于目标）
    Node<K, V> *update[_max_level + 1];  // update 的大小 >= forward
    memset(update, 0, sizeof(Node<K, V>*)*(_max_level + 1)); // 初始化

    // 从最高层开始遍历
    for(int i = _skip_list_level; i >= 0; i--) {
        // 只要当前节点的下一节点非空，且 key 小于目标, 就会向后遍历
        while(current->forward[i] != NULL && current->forward[i]->get_key() < key) {
            current = current->forward[i];  // 节点向后移动，这里你就把forward[i]理解为next就行
        }
        update[i] = current;  // update[i] 记录当前层最后符合要求的节点
    }

    // 遍历到 level 0 说明到达最底层了，forward[0]指向的就是跳表下一个邻近节点
    current = current->forward[0];
    // 注意此时 current->get_key() >= key !!!

    // 1. 插入元素已经存在。插入失败！
    if (current != NULL && current->get_key() == key) {
        std::cout << "key: " << key << ", exists" << std::endl;
        mtx.unlock();
        return 0;  // 插入元素已经存在，返回 -1，插入失败
    }
    // 2. 如果当前 current 不存在，或者 current->get_key > key。则可以插入
    if (current == NULL || current->get_key() != key ) {
        // 随机生成层的高度，也即 forward[] 大小
        int random_level = get_random_level();

        // 如果新添加的节点层高大于当前跳表层高，则需要更新 update 数组
        // 将原本[_skip_list_level random_level]范围内的NULL改为_header
        if (random_level > _skip_list_level) {
            for (int i = _skip_list_level + 1; i < random_level + 1; i++) {
                update[i] = _header;
            }
            _skip_list_level = random_level; // 最后更新跳表层高
        }
        // 创建节点，并进行插入操作
        Node<K, V>* inserted_node = create_node(key, value, random_level);

        // 该操作等价于:
        // new_node->next = pre_node->next;
        // pre_node->next = new_node; 只不过是逐层进行
        for (int i = 0; i <= random_level; i++) {
            inserted_node->forward[i] = update[i]->forward[i];
            update[i]->forward[i] = inserted_node;
        }
        std::cout << "Successfully inserted key: " << key << ", value: " << value << std::endl;
        _element_count ++;  // 更新节点数
    }
    mtx.unlock();
    return 0;  // 返回 0，插入成功
}

1.4 delete_element----删除

如果理解了插入，那么删除也很简单：

  1. 自顶向下找到要删除节点的前一个节点，并保存在指针数组update中。注：update[x]第x层保存要删除节点的前一个节点
  2. 自底向上将跳表重新连接
template<typename K, typename V>
int SkipList<K, V>::delete_element(K key) {
    // 操作同 insert_element
    mtx.lock();
    Node<K, V> *current = this->_header;
    Node<K, V> *update[_max_level + 1];
    memset(update, 0, sizeof(Node<K, V>*)*(_max_level + 1));

    for (int i = _skip_list_level; i >= 0; i--) {
        while (current->forward[i] !=NULL && current->forward[i]->get_key() < key) {
            current = current->forward[i];
        }
        update[i] = current;
    }
    current = current->forward[0];

    // 1. 非空，且 key 为目标值
    if (current != NULL && current->get_key() == key) {
        // 从最底层开始删除 update->forward 指向的节点，即目标节点
        for (int i = 0; i <= _skip_list_level; i++) {
            // 如果 update[i]->forward[i] 已经不指向 current,说明 i 的上层也不会指向 current
            // 也说明了被删除节点层高 i - 1。直接退出循环即可
            if (update[i]->forward[i] != current)
                break;
            // 删除操作，等价于 node->next = node->next->next
            update[i]->forward[i] = current->forward[i];
        }
        // 因为可能删除的元素它的层数恰好是当前跳跃表的最大层数
        // 所以此时需要重新确定 _skip_list_level,通过头节点判断
        while (_skip_list_level > 0 && _header->forward[_skip_list_level] == 0) {
            _skip_list_level --;
        }

        std::cout << "Successfully deleted key : "<< key << std::endl;
        _element_count --;
        mtx.unlock();
        return 0; // 返回值 0 说明成功删除
    }
        // 2. 笔者添加了没有该键时的情况，打印输出提示
    else {
        std::cout << key << " is not exist, please check your input !\n";
        mtx.unlock();
        return -1; // 返回值 -1 说明没有该键值
    }
}

1.5 search_element----查找数据

从最顶层开始遍历，找到最底层中，最后一个满足小于key的节点

template<typename K, typename V>
bool SkipList<K, V>::search_element(K key) {
    std::cout << "search_element..." << std::endl;
    Node<K, V> *current = _header;
    // 从最高层开始遍历，找到最底层中最后一个满足小于key的节点
    for (int i = _skip_list_level; i >= 0; i--) {
        while (current->forward[i] && current->forward[i]->get_key() < key) {
            current = current->forward[i];
        }
    }
    current = current->forward[0]; // 该操作后 current->get_key >= key 或者 null
    // 找到
    if (current != NULL && current->get_key() == key) {
        std::cout << "Found key: " << key << ", value: " << current->get_value() << std::endl;
        return true;
    }
    // 没找到
    std::cout << "Not Found Key: " << key << std::endl;
    return false;
}

1.6 display_list----打印跳表

template<typename K, typename V>
void SkipList<K, V>::display_list() {
    std::cout << "\n******** Skip List ********"<<"\n";
    // 逐层打印
    for (int i = 0; i <= _skip_list_level; i++) {
        Node<K, V> *node = this->_header->forward[i];
        std::cout << "Level " << i << ": ";
        while (node != NULL) {
            std::cout << node->get_key() << ":" << node->get_value() << ";";
            node = node->forward[i];
        }
        std::cout << std::endl;
    }
}

1.7 落盘、加载及其辅助函数

落盘负责：将数据导入磁盘
这里STORE_FILE是我们预定义的文件落盘位置

// 数据落盘到磁盘文件
template<typename K, typename V>
void SkipList<K, V>::dump_file() {
    std::cout << "dump_file..." << std::endl;
    _file_writer.open(STORE_FILE);  // 打开文件，写操作
    Node<K, V> *node = this->_header->forward[0];
    // 只写入键值对，放弃层信息
    while (node != NULL) {
        // 文件写入（key value 以 : 为分隔符），及信息打印
        _file_writer << node->get_key() << ":" << node->get_value() << "\n";
        std::cout << node->get_key() << ":" << node->get_value() << ";\n";
        node = node->forward[0];
    }
    _file_writer.flush();// 刷新
    _file_writer.close();
    return ;
}

加载负责：将数据从磁盘中导入内存，但是层数关系会发生变化

template<typename K, typename V>
void SkipList<K, V>::load_file() {
    _file_reader.open(STORE_FILE);  // 打开文件，读操作
    std::cout << "load_file..." << std::endl;
    std::string line;
    // key 与 value 是一个指向 string 对象的指针
    std::string* key = new std::string();
    std::string* value = new std::string();
    while (getline(_file_reader, line)) { // 一行一行写入
        get_key_value_from_string(line, key, value);  // 辅助函数
        if (key->empty() || value->empty()) {
            continue;
        }
        // 重新载入过程使用 insert_element()
        // 所以层之间的关系(各节点的层高)可能发生变化, 所以与之前的SkipList不同
        insert_element(*key, *value);
        std::cout << "key:" << *key << "value:" << *value << std::endl;
    }
    _file_reader.close();
}

辅助函数:get_key_value_from_string()主要用于在从磁盘中加载数据时，区分出key and value

//辅助函数

// Get current SkipList size 
template<typename K, typename V> 
int SkipList<K, V>::size() { 
    return _element_count;
}

template<typename K, typename V>
void SkipList<K, V>::get_key_value_from_string(const std::string& str, std::string* key, std::string* value) {
    if(!is_valid_string(str)) {
        return;
    }
    // 分隔符之前的为 key, 分隔符之后的为 value
    *key = str.substr(0, str.find(delimiter));
    *value = str.substr(str.find(delimiter) + 1, str.length());
}

template<typename K, typename V>
bool SkipList<K, V>::is_valid_string(const std::string& str) {

    if (str.empty()) {
        return false;
    }
    // 没有发现分隔符
    if (str.find(delimiter) == std::string::npos) {
        return false;
    }
    return true;
}

1.8 clear----清空跳表

template<typename K, typename V> 
void SkipList<K, V>::clear() { 
    std::cout << "clear ..." << std::endl;
    Node<K, V> *node = this->_header->forward[0]; 
    // 删除节点
    while (node != NULL) {
        Node<K, V> *temp = node;
        node = node->forward[0];
        delete temp;
    }
    // 重新初始化 _header
    for (int i = 0; i <= _max_level; i++) {
        this->_header->forward[i] = 0;
    }
    this->_skip_list_level = 0;
    this->_element_count = 0;
}

3. 写跳表项目途中所学习的知识点

1. 流的相关知识

    std::ofstream _file_writer;
    std::ifstream _file_reader;

2. include <mutex>

mutex和之前用的有什么区别

jiong1998
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++实现skip list跳表(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
03-11 398
C++实现skip list跳表实现skip list跳表算法的完整源码（定义，实现，main函数测试） 实现skip list跳表算法的完整源码（定义，实现，main函数测试） #include <array> #include <cstring> #include <ctime> #include <iostream> #include <memory> #include <vector> /** \namespace data_
Skiplist实现——（C++版）
iTer的专栏
10-17 2124
Comparator.h #ifndef __COMPARATOR_H__ #define __COMPARATOR_H__ #include #include template class Comparator : public std::binary_function { public: bool operator() (T t1, T t2) { retu
Skiplist-CPP:A tiny KV storage based on skiplist written in C++ language| 使用C++开发，基于跳表实现的轻量级键值数据库:fire::fire: :rocket:
08-04
KV存储引擎 众所周知，非关系型数据库redis，以及levedb，rockdb其核心存储引擎的数据结构就是跳表。 本项目就是基于跳表实现的轻量级键值型存储引擎，使用C++实现。插入数据、删除数据、查询数据、数据展示、数据落盘、文件加载数据，以及数据库大小显示。 在随机写读情况下，该项目每秒可处理啊请求数（QPS）: 24.39w，每秒可处理读请求数（QPS）: 18.41w 项目中文件 main.cpp 包含skiplist.h使用跳表进行数据操作 skiplist.h 跳表核心实现 README.md 中文介绍 README-en.md 英文介绍 bin 生成可执行文件目录 makefile 编译脚本 store 数据落盘的文件存放在这个文件夹 stress_test_start.sh 压力测试脚本 LICENSE 使用协议 提供接口 insertElement（插入数据） delet
Skiplist-CPP：高效的动态查找结构实现
gitblog_00018的博客
03-24 396
Skiplist-CPP：高效的动态查找结构实现 项目地址:https://gitcode.com/youngyangyang04/Skiplist-CPP 项目简介 Skiplist-CPP 是一个由 C++ 实现的 Skip List 数据结构库。Skip List 是一种概率型数据结构，以其高效且简单的查找、插入和删除操作而闻名。该项目旨在提供一个轻量级、易于集成到其他 C++ 应用程序中的...
skiplist跳表C++实现
03-04
skiplist的C++实现，包含test程序
Skiplist-CPP-master.zip
最新发布
05-22
在这个名为"Skiplist-CPP-master"的项目中，开发者使用C++语言实现了一个基于跳表的轻量级键值存储系统。下面我们将深入探讨跳表的基本原理、C++实现的关键点以及在键值存储中的应用。 1. 跳表基本原理： - 跳表是...
skiplist 跳表C++实现
10-08
跳表（Skip List）是一种高效的查找数据结构，它利用了概率算法来提高查询效率，通常用于数据库和搜索引擎中。在C++中实现跳表，我们可以利用STL中的容器和算法库来简化工作，同时理解其背后的原理至关重要。 跳表...
skipList.rar
04-21
本压缩包"skipList.rar"包含了一个用C++实现的跳跃表，该实现参考了Redis中的zskiplist。下面将详细介绍跳跃表的概念、工作原理以及C++实现的关键点。 跳跃表是一种随机化的数据结构，由多个层（level）组成，每层...
Redis实现skipList(跳表) 代码有详解
m0_63743577的博客
07-16 752
Redis实现skipList(跳表) 本项目就是基于跳表实现的轻量级键值型存储引擎，使用C++实现。插入数据、删除数据、查询数据、数据展示、数据落盘、文件加载数据，以及数据库大小显示。
C++ SkipList简单实现
xupeng1644的博客
11-11 2205
SkipList.h： #pragma once #include <vector> struct SkipListNode { SkipListNode(int data, int level); int m_data; std::vector<SkipListNode*> m_forward; }; class SkipList { public: Ski...
Go-skiplist-Skiplist在Go中的实现
08-14
skiplist - Skiplist 在Go中的实现
跳跃表（skiplist ）详解及其C++编程实现
JMW1407的博客
11-18 2572
跳表SkipList跳表SkipList1、背景2、定义2.1、SkipList基本数据结构及其实现3、实现4、使用方法4.1、跳表的创建4.2、跳表插入操作参考 跳表SkipList 1、背景 为什么选择跳表？ 目前经常使用的平衡数据结构有：B树，红黑树，AVL树，Splay Tree, Treep等。跳表是平衡树的一种替代的数据结构，但是和红黑树不相同的是，跳表对于树的平衡的实现是基于一种随机化的算法的，这样也就是说跳表的插入和删除的工作是比较简单的。 用跳表吧，跳表是一种随机化的数据结构，目前开源软件
浅析SkipList跳跃表原理及代码实现
木牛的博客
05-24 221
转载请注明：http://blog.csdn.net/ict2014/article/details/17394259 SkipList在leveldb以及lucence中都广为使用，是比较高效的数据结构。由于它的代码以及原理实现的简单性，更为人们所接受。我们首先看看SkipList的定义，为什么叫跳跃表？ “ Skip lists are data structures that use probabilistic balancing rather than strictly en...
Skip List--跳表（全网最详细的跳表文章没有之一）
StudyWinter的博客
10-27 949
跳表是可以实现二分查找的有序链表；每个元素插入时随机生成它的level；最底层包含所有的元素；如果一个元素出现在level(x)，那么它肯定出现在x以下的level中；每个索引节点包含两个指针，一个向下，一个向右；（笔记目前看过的各种跳表源码实现包括Redis 的zset 都没有向下的指针，那怎么从二级索引跳到一级索引呢？留个悬念，看源码吧，文末有跳表实现源码）跳表查询、插入、删除的时间复杂度为O(log n)，与平衡二叉树接近；
YDB针对范围查找所做的性能小改进（skiplist IO 分析）
qq_33160722的博客
01-30 771
范围查找，尤其是时间范围的查找，在日常检索中会被经常使用，在范围查找中跳跃表的利用与否对性能影响非常大。  我们对lucene的默认范围查找做了一个小实验，截获了每种SQL的IO读取明细，对IO情况做了测试与分析。 测试结果如下 普通的等值SQL分析-占用IO较小  筛选条件为：phonenum='13470881895' and amtdouble=50 使用小范围
SkipList 跳表
NowOrNever
01-16 2877
链表结构能够做到并发无锁的增加新节点，但不能很容易的访问到中值（因为链表只能从头部遍历或尾部遍历）。平衡有序二叉树则相反，虽然很容易可以访问到全部数据的中值，但无法做到并发无锁的增加新节点。 在90年代之前，人们一直以“这就是生活” 来安慰自己，认为鱼与熊掌不可兼得。但在90年代，William Pugh 在他的论文中提出了一种新的数据结构skiplist，很巧妙的解决了这个矛盾
数据结构学习——skiplist跳表
baidu_15952103的博客
10-11 815
目录 1.skiplist简介 2.skiplist核心思想 3.skiplist原理 3.1 跳表的查找 3.2 跳表的插入 3.3跳表的删除 4.skiplist简单实现 1.skiplist简介 Skiplist是一个用于有序元素序列快速搜索的数据结构，由美国计算机科学家William Pugh发明于1989年。他在论文《Skip lists: a probabilistic alternative to balanced trees》中详细介绍了跳表的数据结构和插入删除等...
Skip List——跳表，一个高效的索引技术
weixin_33827731的博客
06-25 524
对于一个查询任务，如果不能开辟连续空间进而采样二分查找进行处理的话，通常各种树，各种碉堡的更高级的数据结构就会被提出，用来快速进行数据查询。 在这里，我无意显示自己的高人一等或是弱智一面，但是对于常见的数据结构，用于动态处理一组数据的索引构建工作，采样的多个数据结构都面临一个复杂编程过程，程序难以调试，算法难以理解的问题，而跳表——可以在满足O(LogN)的查询复杂度的前提下，十分简单的完成数据...
二叉树 跳表_面试题之跳表
weixin_31220971的博客
01-16 432
本文主要讲解跳表的原理、代码实现以及与之相关的常见面试题。跳表本质上是一种查找结构，相比于平衡树，不仅实现简单，而且插入、删除、查找的时间复杂度均为O(logN)。跳表其实就是链表，只是对有序的链表增加上附加的前进链接（增加是以随机化的方式进行的），所以在列表中的查找可以快速的跳过部分列表从而快速检索。由于跳表在Redis的使用，导致面试中经常会被提及，所以深入了解跳表的实现非常必要。代码实现第一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值