代码实现：跳表小项目

最新推荐文章于 2023-05-04 12:14:11 发布
最新推荐文章于 2023-05-04 12:14:11 发布
阅读量234 收藏 1
点赞数 1
分类专栏： C++开发后端基础知识 文章标签： c++ c语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/IS_MOKE/article/details/129051774
版权

main.cpp


#include <iostream>
#include "skiplist.h"
#define FILE_PATH "./store/dumpFile"

int main() {

    // 键值中的key用int型，如果用其他类型，需要自定义比较函数
    // 而且如果修改key的类型，同时需要修改skipList.load_file函数
    SkipList<int, std::string> skipList(6);
	skipList.insert_element(1, "好好"); 
	skipList.insert_element(3, "学"); 
	skipList.insert_element(7, "习"); 
	skipList.insert_element(8, "天天"); 
	skipList.insert_element(9, "向"); 
	skipList.insert_element(19, "上"); 
	skipList.insert_element(19, "！"); 

    std::cout << "skipList size:" << skipList.size() << std::endl;

    skipList.dump_file();

    // skipList.load_file();

    skipList.search_element(9);
    skipList.search_element(18);


    skipList.display_list();

    skipList.delete_element(3);
    skipList.delete_element(7);

    std::cout << "skipList size:" << skipList.size() << std::endl;

    skipList.display_list();
}

skiplist.h

#include <iostream> 
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <mutex>
#include <fstream>

#define STORE_FILE "store/dumpFile"

std::mutex mtx;
std::string delimiter = ":";

//class template to implement node
template<typename K, typename V>
class Node{
public:
    Node(){}
    
    Node(K k, V v,int);
    
    ~Node();
    
    K get_key() const;
    
    V get_value() const;
    
    void set_value(V);

    //Linear array to hold pointers to next of different level
    Node<K,V> **forward;
    
    int node_level;
private:
    K key;
    V value;
};

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,因为数组的下表是从0-level
    this->forward = new Node<K,V>*[level+1];

    //把forward数组里面初始化为0
    memset(this->forward,0,sizeof(Node<K,V>*)*(level+1));

};

template<typename K, typename V>
Node<K,V>::~Node(){
    delete []forward;
};

template<typename K, typename V>
K Node<K,V>::get_key() const{
    return key;
};

template<typename K, typename V>
V Node<K,V>::get_value() const{
    return value;
};

template<typename K, typename V>
void Node<K,V>::set_value(V value){
    this->value=value ;
};


//class template for skip list
template<typename K,typename V>
class SkipList{
public:
    SkipList(int);
    ~SkipList();
    int get_random_level();
    Node<K,V>* create_note(K,V,int);
    int insert_element(K,V);
    void display_list();
    bool search_element(K);
    void delete_element(K);
    //转储
    void dump_file();
    void load_file();
    int size();

private:
    void get_key_value_from_string(const std::string& str,std::string* key,std::string* value);
    bool is_valid_string(const std::string& str);

    //maximum level of the skip list
    int _max_level;

    //current level of skip list
    int _skip_list_level;

    //pointer to header node
    Node<K,V> *_header;

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

    //skiplist current element count
    int _element_count;
};

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

// Insert given key and value in skip list 
// return 1 means element exists  
// return 0 means insert successfully
/* 
                           +------------+
                           |  insert 50 |
                           +------------+
level 4     +-->1+                                                      100
                 |
                 |                      insert +----+
level 3         1+-------->10+---------------> | 50 |          70       100
                                               |    |
                                               |    |
level 2         1          10         30       | 50 |          70       100
                                               |    |
                                               |    |
level 1         1    4     10         30       | 50 |          70       100
                                               |    |
                                               |    |
level 0         1    4   9 10         30   40  | 50 |  60      70       100
                                               +----+
*/
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;

    //创建更新数组，初始化数组
    //更新数组中是node->forward[i]要放的值，也就是小于key的最大值
    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;
    }

    //在第0层，让forward指向右边的节点，也就是想要插入的值，即大于key的最小值
    current = current->forward[0];

    //插入的值已经存在
    if(current!=NULL && current->get_key() == key){
        std::cout<<"key: "<<key<<" ,exists"<<std::endl;
        mtx.unlock();
        return 1;
    }

    //当前节点为空时
    //当前阶段不为空时，要插入节点在update【0】和current
    if(current == NULL || current ->get_key() !=key ){

        //为节点生成一个随机的层数
        int random_level= get_random_level();

        //如果随即层数是大于跳表的目前层数，初始化大于的层数的指针为头指针
        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
        Node<K,V>* insert_node = create_note(key,value,random_level);

        // 插入节点
        for(int i=0;i<=random_level;++i){
            insert_node->forward[i]=update[i]->forward[i];
            update[i]->forward[i]=insert_node;
        }
        std::cout<< "Successfully inserted key: "<< key <<" , value: "<<value<<std::endl;
        _element_count++;
    }
    mtx.unlock();
    return 0;
}

//  显示跳表
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;
    }
}

// 转存数据到文件
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){
        _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;
    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(*key,*value);
         std::cout << "key:" << *key << "value:" << *value << std::endl;
    }
    _file_reader.close();
}

// 获取跳表的大小
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=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;
}

// 从跳表中删除元素
template<typename K,typename V>
void SkipList<K,V>::delete_element(K key){

    mtx.lock();
    Node<K,V>* current = this->_header;

    //创建更新数组，初始化数组
    //更新数组中是node->forward[i]要放的值，也就是小于key的最大值
    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;
    }

    //在第0层，找到想要删除值的节点
    current = current->forward[0];

    if(current!=NULL && current->get_key()==key){

        // 从最底层开始遍历，删除每一层中的值
        for(int i=0;i<=_skip_list_level;++i){
        
            // 如果这一层中没有该节点，则以上层都没有
            if(update[i]->forward[i]!=current)
                break;
        
            update[i]->forward[i]=current->forward[i];
        }

        // 移除没有使用过的层数
        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();
}

// Search for element in skip list 
/*
                           +------------+
                           |  select 60 |
                           +------------+
level 4     +-->1+                                                      100
                 |
                 |
level 3         1+-------->10+------------------>50+           70       100
                                                   |
                                                   |
level 2         1          10         30         50|           70       100
                                                   |
                                                   |
level 1         1    4     10         30         50|           70       100
                                                   |
                                                   |
level 0         1    4   9 10         30   40    50+-->60      70       100
*/
template<typename K,typename V>
bool SkipList<K,V>::search_element(K key){

    std::cout << "search_element-----------------" << std::endl;
    Node<K,V>* current=_header;

    // 从跳表的最高层开始查找,比要求值小的最大值
    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];

    //如果节点存在
    if(current &&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;
}

// 构造跳表
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;

    //创建系欸但，初始化kv为空
    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_reader.is_open())
        _file_reader.close();
    if(_file_writer.is_open())
        _file_writer.close();
    delete _header;
}

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

    int k=1;
    while(rand()%2){
        ++k;
    }
    k=(k<_max_level)?k:_max_level;
    return k;
}

在这里插入图片描述

stress_test.cpp

#include <iostream>
#include <chrono>
#include <cstdlib>
#include <pthread.h>
#include <time.h>
#include "../skiplist.h"


#define NUM_THREADS 1
#define TEST_COUNT 100000

SkipList<int,std::string> skipList(18);

void *insertElement(void* threadid){
    long tid;
    tid =(long)threadid;
    std::cout << tid << std::endl;
    int tmp=TEST_COUNT/NUM_THREADS;
    for(int i=tid*tmp,count=0;count<tmp;++i){
        ++count;
        skipList.insert_element(rand()%TEST_COUNT,"a");

    }
    pthread_exit(NULL);
}

void *getElement(void* threadid) {
    long tid; 
    tid = (long)threadid;
    std::cout << tid << std::endl;  
    int tmp = TEST_COUNT/NUM_THREADS; 
	for (int i=tid*tmp, count=0; count<tmp; i++) {
        count++;
		skipList.search_element(rand() % TEST_COUNT); 
	}
    pthread_exit(NULL);
}


int main()

{
    srand(time(NULL));
    
    pthread_t threads[NUM_THREADS];
    int rc;
    int i;

    auto start = std::chrono::high_resolution_clock::now();

    for(i =0;i <NUM_THREADS;++i){
        std::cout << "main() : creating thread, " << i << std::endl;
        rc=pthread_create(&threads[i],NULL,insertElement,(void* )i);

        if(rc){
            std::cout << "Error:unable to create thread," << rc << std::endl;
            exit(-1);
        }
    }

    void *ret;
    for(i=0;i<NUM_THREADS;++i){
        if(pthread_join(threads[i],&ret)!=0){
            perror("pthread_create() error");
            exit(3);
        }
    }
    auto finish = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> elapsed =finish - start;
    std::cout << "insert elapsed:" << elapsed.count() << std::endl;
    pthread_exit(NULL);

        // pthread_t threads[NUM_THREADS];
        // int rc;
        // int i;
        // auto start = std::chrono::high_resolution_clock::now();

        // for( i = 0; i < NUM_THREADS; i++ ) {
        //     std::cout << "main() : creating thread, " << i << std::endl;
        //     rc = pthread_create(&threads[i], NULL, getElement, (void *)i);

        //     if (rc) {
        //         std::cout << "Error:unable to create thread," << rc << std::endl;
        //         exit(-1);
        //     }
        // }

        // void *ret;
        // for( i = 0; i < NUM_THREADS; i++ ) {
        //     if (pthread_join(threads[i], &ret) !=0 )  {
        //         perror("pthread_create() error"); 
        //         exit(3);
        //     }
        // }

        // auto finish = std::chrono::high_resolution_clock::now(); 
        // std::chrono::duration<double> elapsed = finish - start;
        // std::cout << "get elapsed:" << elapsed.count() << std::endl;
    return 0;

}

作者的测试结果
在这里插入图片描述
自己的测试结果：
插入十万条数据
在这里插入图片描述
读取十万条数据
在这里插入图片描述
待优化：
delete的时候没有释放内存。
跳表的key用int型，如果使用其他类型需要自定义比较函数，当然把这块抽象出来更好。

参考项目：https://github.com/youngyangyang04/Skiplist-CPP

在三年之后
关注
专栏目录
跳表的C++实现
Castria的博客
11-07 2659
跳表(Skip List)是在链表基础上进行改进的一种有序的数据结构，它为了便于查找，在插入过程中随机地将一些元素提升为高度为1~r的索引，以此来加快之后的操作。索引可以分为多层，一般而言，层数越高的索引个数越少。下面的图是一个跳表示例（隐去表头，上面的为高层） 为了方便下面对代码实现的说明，先给出各数据类型的定义。 template<typename T> class skiplist { private: static constexpr int MAX_LEVEL = 16; s
本项目使用C++实现基于跳表实现的轻量级键值型存储引擎，其主要功能有：插入数据、查询数据、删除数据、数据展示、数据库.zip
最新发布
03-06
C++中可能使用STL的`map`或`unordered_map`作为基础数据结构，但为了实现跳表的高效插入，开发者可能自定义了数据结构。 2. 查询数据：查询数据时，根据键在跳表的各层索引中逐级向下查找，直到找到目标键或者搜索...
跳表完整代码
03-17
跳表完整代码
项目：跳表
chenzx1999的博客
05-04 122
（1）跳表是可以实现二分查找的有序链表；（2）每个元素插入时随机生成它的level；（3）最低层包含所有的元素；（4）如果一个元素出现在level(x)，那么它肯定出现在x以下的level中；（5）每个索引节点包含两个指针，一个向下，一个向右；（6）跳表查询、插入、删除的时间复杂度为O(log n)，与平衡二叉树接近；
skiplist - 跳表
一七令
06-30 773
跳表(skiplist、跳跃表) 是一个很优秀的数据结构，比如用于 Redis、levelDB等出名的开源项目上。跳表在原有的有序链表上面增加了多级索引，通过索引来实现快速查找。它的结构特点在名称能很好的体现出来，就像兔子一样，蹦蹦跳跳。可以结合下面的图有个初步的印象。是不是看起来很形象了，接下来看看 Redis 是怎么实现跳表。跳表是一个随机化的数据结构，实质就是一种可以进行二分查找的有序链表。跳表在原有的有序链表上面增加了多级索引，通过索引来实现快速查找。...
Bugku web — ereg正则%00截断(代码审计) ——详细题解
日熙的博客
09-28 2640
题目地址： http://123.206.87.240:9009/5.php 整理一下代码如下： if (isset ($_GET['password'])) { if (ereg ("^[a-zA-Z0-9]+$", $_GET['password']) === FALSE) { echo '<p>You password must be alphanumeric</p>'; } else if (strlen($_GET['password']) < 8 &am
Skip List--跳表（全网最详细的跳表文章没有之一）
StudyWinter的博客
10-27 2065
跳表是可以实现二分查找的有序链表；每个元素插入时随机生成它的level；最底层包含所有的元素；如果一个元素出现在level(x)，那么它肯定出现在x以下的level中；每个索引节点包含两个指针，一个向下，一个向右；（笔记目前看过的各种跳表源码实现包括Redis 的zset 都没有向下的指针，那怎么从二级索引跳到一级索引呢？留个悬念，看源码吧，文末有跳表实现源码）跳表查询、插入、删除的时间复杂度为O(log n)，与平衡二叉树接近；
C++课程作业基于跳表实现的轻型键值型数据库源码+项目说明.zip
08-10
C++课程作业基于跳表实现的轻型键值型数据库源码+项目说明.zip 1、该资源内项目代码都是经过测试运行成功，功能ok的情况下才上传的，请放心下载使用！ 2、本项目适合计算机相关专业(如计科、人工智能、通信工程、...
跳表 java实现
01-29
在给定的压缩包文件中，`SkipList`很可能包含了实现跳表的Java源代码，包括`Node`类以及跳表的主类，可能还有测试用例。这些代码提供了实际的实现细节，可以帮助我们更深入地理解跳表的工作原理和Java编程技巧。通过...
跳表java_Java跳表(SkipList)的实现
weixin_32968105的博客
02-16 198
跳表，是基于链表实现的一种类似“二分”的算法。它可以快速的实现增，删，改，查操作。package structs;import java.util.Random;public class SkipList {private static final int MAX_LEVEL = 16;private int levelCount = 1;private Node head = new Node(...
skiplist 跳表C++实现
10-08
skiplist 跳表C++实现,资料参考 en.wikipedia.org/wiki/Skip_list
基于跳表实现的轻量级KV存储引擎 项目总结
Ray Home
06-07 5670
基于跳表实现的KV存储引擎 项目学习总结
C++实现KV跳表
qq_43287931的博客
01-11 1797
用C++实现KV跳表 本项目就是基于跳表实现的轻量级键值型存储引擎，使用C++实现。插入数据、删除数据、查询数据、数据展示、数据落盘、文件加载数据，以及数据库大小显示。 skiplist.h 跳表核心实现 #include <iostream> #include <cstdlib> #include <cmath> #include <cstring> #include <mutex> #include <fstream> #def
2021-07/08收集字节跳动---Java提前批面试题
08-08 7951
一、字节提前批java后台开发面试一面 1. 字符编码的utf8 gbk为什么设计这么多格式。 1）ASCII 编码 众所周知，计算机只能处理0和1，任何符号都转换为0和1的序列才能处理。计算机中8个位（bit）作为一个字节，所以1个字节能产生2的8次方个0和1的不同组合，也就是说1个字节做多能表示256种字符。ASCII编码就是用1个字节来存储字符，计算机最初是美国人发明的，他们的符号不多，所以还将8个0和1序列中的第一位固定为0，ASCII只能表示127个字符。 2）GBK 编码 美国佬的符号不多，所以
考研失利后，我学了四个月
博客
08-12 617
作者：阿秀校招八股文学习网站：https://interviewguide.cn你好，我是阿秀。近两年计算机考研越来越火，很多学弟学妹也都会在大三时选择考研，去搏一搏。尽管研究生持续在扩招，但每年能上岸的还是杯水车薪，很多人也都会在考研和就业二者之间来回徘徊。今天想分享学习圈里一位学弟考研失利后选择就业的文章，这位学弟跟我一样，都是普通二本的出身。这位学弟参加的是22考研...
字节腾讯三轮社招面经（附个人回答）
gu1857035894的博客
10-18 2693
背景 本人2本毕业，目前工作四年，一直是Java。做的都是些二线公司，没做过一线。四年跳了三家公司。在家休息了几个月，五月中旬开始面试。 字节跳动 由于跳槽过多而且已经是淡季的原因。内推的我的字节哥们儿，推了不知道多少个部门，从字节海外电商推到教育线简历都由于频繁跳槽都挂了。最后才被广告营销捞了起来（而且居然是个Java部门）。这里还是奉劝大家跳槽不要像我这么频繁，唉。另外大厂，建议找人内推。这是我第一次面字节，也是今年第一场面试，各种意义都算是初体验了233。 字节跳动1面： 一面是
跳表（Skip List）
热门推荐
https://juejin.cn/user/4248168663101239/posts
04-30 2万+
跳表SkipList一. 跳表的定义 一. 跳表的定义 跳表(SkipList)：增加了向前指针的链表叫做指针。跳表全称叫做跳跃表，简称跳表。跳表是一个随机化的数据结构，实质是一种可以进行二分查找的有序链表。跳表在原有的有序链表上增加了多级索引，通过索引来实现快速查询。跳表不仅能提高搜索性能，同时也可以提高插入和删除操作的性能。 跳表是一个随机化的数据结构，可以被看做二叉树的一个变种，它在性能上和红黑树、AVL树不相上下，但是跳表的原理非常简单，目前在Redis和LevelDB中都有用到。 ...
跳跃表的基本概念以及代码实现详解
wanghao112956的博客
08-27 1329
一 简介 （想自学习编程的小伙伴请搜索圈T社区，更多行业相关资讯更有行业相关免费视频教程。完全免费哦!） （1）什么是跳跃表？ 所谓跳跃表，就是在普通链表的基础上增加了多层索引链表，这样在查找时就可以通过在上下不同层级的索引链表间跳跃，以达到快速查找的目的。 当然，我这样说可能比较抽象，下面我用一张图来简单解释一下。 从上面这张图可以看出，跳跃表有三种不同的对象。 i）以蓝色表示的数据链表： 图...
跳跃表-原理及Java实现
weixin_33949359的博客
04-25 1779
跳跃表-原理及Java实现 引言： 上周现场面试阿里巴巴研发工程师终面，被问到如何让链表的元素查询接近线性时间。笔者苦思良久，缴械投降。面试官告知回去可以看一下跳跃表，遂出此文。 跳跃表的引入 我们知道，普通单链表查询一个元素的时间复杂度为O(n)，即使该单链表是有序的，我们也不能通过2分的方式缩减时间复杂度。 如上图，我们要查询元素为55的...
数据结构精要第二部分：跳表与哈希表解析
作者Robert Horvick和Daniel Jebaraj通过深入浅出的方式，详细讲解了这些数据结构的工作原理、实现代码以及它们在实际应用中的变种。 跳表(Skip Lists) 跳表是一种高效的数据结构，用于实现有序集合的快速查找、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值