跳表 （Skip List） C++ 实现

最新推荐文章于 2023-03-04 21:47:40 发布
最新推荐文章于 2023-03-04 21:47:40 发布
阅读量879 收藏 6
点赞数 1
分类专栏： Linux
原文链接：https://blog.csdn.net/weixin_44387066/article/details/90766034
版权

跳表 （Skip List） C++ 实现


跳表原理
跳表 c++ 实现
SkipNode
SkipList
随机层数
结点最大层数
基本操作
打印
主函数
输出结果
在学习 C++ 中的过程中，找个算法作为练习。
仅供参考。

跳表原理


跳表原理讲解请参考 https://lotabout.me/2018/skip-list/
为了节约时间，这里只是简单说明，原文如上。

跳表(skip list) 对标的是平衡树(AVL Tree)，是一种 插入/删除/搜索 都是 O ( l o g n ) O(log n)O(logn) 的数据结构。它最大的优势是原理简单、容易实现、方便扩展、效率更高。因此在一些热门的项目里用来替代平衡树，如 redis, leveldb 等。

跳表顾名思义就是跳跃的表格，理解起来其实就是跳着插入或者搜索。具体什么意思呢，其实就像是二分搜索一样，每次都将数组分成两点分，先定位搜索或者插入的数据在哪一部分，就可以节约搜索的时间。跳表其实是一样的原理，即建立多层索引（多层链表）。如果每次都是以二等分来建立索引的话，即如下图所示：

在这里插入图片描述

但是上述结构是“静态”的，即我们先拥有了一个链表，再在之上建了多层的索引。但是在实际使用中，我们的链表是通过多次插入/删除形成的，换句话说是“动态”的。上述的结构要求上层相邻节点与对应下层节点间的个数比是 1:2，随意插入/删除一个节点，这个要求就被被破坏了。

因此跳表（skip list）表示，我们就不强制要求 1:2 了，一个节点要不要被索引，建几层的索引，都在节点插入时由抛硬币决定。当然，虽然索引的节点、索引的层数是随机的，为了保证搜索的效率，要大致保证每层的节点数目与上节的结构相当。下面是一个随机生成的跳表：

在这里插入图片描述
对于上述随机跳表而言，每次插入一个新结点的时候，该结点的索引层数是抛硬币决定的，即由随机算法决定的。

当然为了防止运气太好，层数太高，我们一般会设置一个最大的层数 M a x L e v e l MaxLevelMaxLevel. 一般 M a x L e v e l = l o g 1 / p n MaxLevel=log_{1/p}nMaxLevel=log 
1/p
​    
 n。 p pp 为概率。

跳表 c++ 实现
思路：

首先创建一个结点的结构体，结构体里包含 一个键值对，key 用来建立索引，而 value 则用于存储真正的值；指向下一个结点的指针 next，以及标志每个结点索引层数的参数 level. next 指针是一个数组，用于存储结点在所有层数上的下一个结点。 例如， 上述图中结点6的next指针为{NIL, 25, 9, 7}.
创建class skipList, 包含头结点，尾结点，list 的最大层数，随机层数方法，以及一些列操作。
头结点和尾节点分别为整型的最小值和最大值，并在初始化时让所有层数上的头结点都指向尾节点。
操作包含插入，查找，删除。
SkipNode
为了可以适用于任何类型的value， 这里用了 template

template<typename T>
struct SkipNode
{
    int key;
    T value;
    vector<SkipNode*> next;    SkipNode(int k, T v, int level);
};



//构造函数，初始化

template<typename T> SkipNode<T>::SkipNode(int k, T v, int level) 
    : key(k), value(v)
{
    for (int i = 0; i < level; i++)
    {
        next.push_back(nullptr);
    }
}


SkipList

template<class T>
class SkipList
{

public:
    //头结点
    SkipNode<T>* head;
    
    //列表最大层数
    int maxLevel;

    //整型的最小值和最大值
    const int minInt = numeric_limits<int>::min();
    const int maxInt = numeric_limits<int>::max();

public:
    //构造函数
    SkipList(int maxLevel, T iniValue);

    //析构函数
    ~SkipList();

    //随机层数方法
    int randomLevel();

    //插入, 查找， 删除
    SkipNode<T>* insert(int k, T v);
    SkipNode<T>* find(int k);
    SkipNode<T>* deleteNode(int k);

    //打印
    void printNode();

private:

    //尾节点
    SkipNode<T>* tail;
    
    //找到当前列表或者node的最大层数
    int nodeLevel(vector<SkipNode<T>*> p);
};

//初始化
template<class T> SkipList<T>::SkipList(int maxLevel, T iniValue)
    : maxLevel(maxLevel)
{
    //初始化头结点和尾节点为整型最小值和最大值
    head = new SkipNode<T>(minInt, iniValue, maxLevel);
    tail = new SkipNode<T>(maxInt, iniValue, maxLevel);

    //所有层数上的头结点指向尾节点
    for (int i = 0; i < maxLevel; i++)
    {
        head->next[i] = tail;
    }
}

template<class T> SkipList<T>::~SkipList()
{
    delete head;
    delete tail;
}

随机层数


用 time 作为种子来获取（0，1）的随机值。 level ++ 直到随机值为 0 或者超过最大层数。

template<class T> int SkipList<T>::randomLevel()
{
    int random_level = 1;
    int seed = time(NULL);
    static default_random_engine e(seed);
    static uniform_int_distribution<int> u(0, 1);

    while (u(e) && random_level < maxLevel)
    {
        random_level++;
    }

    return random_level;
}


结点最大层数


返回当前node的最大层数，最小值为 1.

template<class T> int SkipList<T>::nodeLevel(vector<SkipNode<T>*> next)
{
    int node_level = 0;
    
    if (next[0]->key == maxInt)
    {
        return node_level;
    }

    for (int i = 0; i < next.size(); i++)
    {
        if (next[i] != nullptr && next[i]->key != maxInt)
        {
            node_level++;
        }
        else
        {
            break;
        }
    }
    return node_level;
}



基本操作

/*插入：
1）首先用查找函数来判断该结点是否已经存在，如果存在，则更新该结点的值
2）获取新节点的随机层数
3）找到合适的插入位置
4）插入，并调整每层前后node的指针*/
template<class T> SkipNode<T>* SkipList<T>::insert(int k, T v)
{
	int x_level = randomLevel();
	SkipNode<T>* new_node = nullptr;
	SkipNode<T>* tmp = head;

	new_node = find(k);

	if (new_node) {
		
		new_node->value = v;
		cout << "\nThis node " << k << " has already existed. And its value has been updated to " << v << endl;
		return head;
	}

	cout << "key: " << k << ", randomLevel: " << x_level << endl;

	new_node = new SkipNode<T>(k, v, x_level);

	for (int i = (x_level - 1); i > -1; i--)
	{
		while (tmp->next[i] != nullptr && tmp->next[i]->key < k)
		{
			tmp = tmp->next[i];
		}

		new_node->next[i] = tmp->next[i];
		tmp->next[i] = new_node;
	}

	return head;
}

/*查找：
由于列表有序，首先找到小于该结点的最近的结点，如果下一个结点等于目标结点，则返回该节点。
如果不是，则返回空*/
template<class T> SkipNode<T>* SkipList<T>::find(int x)
{
	SkipNode<T>* tmp = head;
	int current_level = nodeLevel(tmp->next);

	for (int i = (current_level - 1); i > -1; i--)
	{
		while (tmp->next[i] != nullptr && tmp->next[i]->key < x)
		{
			tmp = tmp->next[i];
		}
	}
	tmp = tmp->next[0];

	if (tmp->key == x)
	{
		cout << "\nThis key " << x << " has been found\n";
		return tmp;
	}
	else
	{
		//cout << " \nThis key " << x << " doesn't exit\n";
		return nullptr;
	}
}

/*删除：
1) 用 find(x) 方法判断该结点是否存在. 如果不存在，则返回当前list, 并告知该结点不存在。
2) 找到小于该结点的最近的结点。
3) 更改该节点每层的前面的结点的指针。*/
template<class T> SkipNode<T>* SkipList<T>::deleteNode(int x)
{
	SkipNode<T>* node = find(x);
	if (!node)
	{
		cout << "\n This deleting node" << x << "doesn't exist" << endl;
		return head;
	}
	else
	{
		SkipNode<T>* tmp = head;
		int x_level = node->next.size();

		cout << "\nThe deleting node " << x << "'s level is " << x_level << endl;

		for (int i = (x_level - 1); i > -1; i--)
		{
			while (tmp->next[i] != nullptr && tmp->next[i]->key < x)
			{
				tmp = tmp->next[i];
			}
			tmp->next[i] = tmp->next[i]->next[i];

			cout << "This node " << x << " has been deleted from level " << i << endl;
		}

		return head;
	}
}


打印

// 分层打印
template<class T> void SkipList<T>::printNode()
{

    for (int i = 0; i < maxLevel; i++)
    {
        SkipNode<T>* tmp = head;
        int lineLen = 1;

        if (tmp->next[i]->key != maxInt)
        {
            cout << "\n";
            cout << "This is level " << i << ":" << endl;
            cout << "{";

            while (tmp->next[i] != nullptr && tmp->next[i]->key != maxInt)
            {
                cout << "(" << "Key: " << tmp->next[i]->key << ", ";
                cout << "Value: " << tmp->next[i]->value << ")";

                tmp = tmp->next[i];

                if (tmp->next[i] != nullptr && tmp->next[i]->key != maxInt)
                {
                    cout << ", ";
                }                if (lineLen++ % 5 == 0) cout << "\n";
            }
            cout << "}" << "\n";
        }
    }
}


主函数

int main()
{
    int maxLevel = 6;
    SkipList<int> l(maxLevel, 0);

    for (size_t i = 0; i < 50; i++)
    {
        l.insert(i, i);
    }    l.printNode();


输出结果

This is level 0:
{(Key: 0, Value: 0), (Key: 1, Value: 1), (Key: 2, Value: 2), (Key: 3, Value: 3), (Key: 4, Value: 4),
(Key: 5, Value: 5), (Key: 6, Value: 6), (Key: 7, Value: 7), (Key: 8, Value: 8), (Key: 9, Value: 9),
(Key: 10, Value: 10), (Key: 11, Value: 11), (Key: 12, Value: 12), (Key: 13, Value: 13), (Key: 14, Value: 14),
(Key: 15, Value: 15), (Key: 16, Value: 16), (Key: 17, Value: 17), (Key: 18, Value: 18), (Key: 19, Value: 19),
(Key: 20, Value: 20), (Key: 21, Value: 21), (Key: 22, Value: 22), (Key: 23, Value: 23), (Key: 24, Value: 24),
(Key: 25, Value: 25), (Key: 26, Value: 26), (Key: 27, Value: 27), (Key: 28, Value: 28), (Key: 29, Value: 29),
(Key: 30, Value: 30), (Key: 31, Value: 31), (Key: 32, Value: 32), (Key: 33, Value: 33), (Key: 34, Value: 34),
(Key: 35, Value: 35), (Key: 36, Value: 36), (Key: 37, Value: 37), (Key: 38, Value: 38), (Key: 39, Value: 39),
(Key: 40, Value: 40), (Key: 41, Value: 41), (Key: 42, Value: 42), (Key: 43, Value: 43), (Key: 44, Value: 44),
(Key: 45, Value: 45), (Key: 46, Value: 46), (Key: 47, Value: 47), (Key: 48, Value: 48), (Key: 49, Value: 49)
}

This is level 1:
{(Key: 0, Value: 0), (Key: 4, Value: 4), (Key: 6, Value: 6), (Key: 10, Value: 10), (Key: 14, Value: 14),
(Key: 15, Value: 15), (Key: 17, Value: 17), (Key: 21, Value: 21), (Key: 22, Value: 22), (Key: 23, Value: 23),
(Key: 28, Value: 28), (Key: 30, Value: 30), (Key: 34, Value: 34), (Key: 35, Value: 35), (Key: 36, Value: 36),
(Key: 38, Value: 38), (Key: 39, Value: 39), (Key: 42, Value: 42), (Key: 46, Value: 46), (Key: 48, Value: 48),
(Key: 49, Value: 49)}

This is level 2:
{(Key: 4, Value: 4), (Key: 21, Value: 21), (Key: 23, Value: 23), (Key: 34, Value: 34), (Key: 35, Value: 35),
(Key: 39, Value: 39), (Key: 42, Value: 42), (Key: 46, Value: 46)}

This is level 3:
{(Key: 4, Value: 4), (Key: 46, Value: 46)}

This is level 4:
{(Key: 46, Value: 46)}


————————————————
版权声明：本文为CSDN博主「啦啦啦啦啦~~」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_44387066/article/details/90766034

致守
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
skiplist 跳表C++实现
10-08
skiplist 跳表C++实现,资料参考 en.wikipedia.org/wiki/Skip_list
skiplist数据结构简介
chuixieli7527的博客
10-03 427
skiplist数据结构简介 skiplist本质上也是一种查找结构，用于解决算法中的查找问题（Searching），即根据给定的key，快速查到它所在的位置（或者对应的value）。 一般查找问题的解法分为两个大类：一个是基于各种平衡树，一个是基于哈希表。但skiplist却比较特殊，它没法...
跳表的C++实现
Castria的博客
11-07 2612
跳表(Skip List)是在链表基础上进行改进的一种有序的数据结构，它为了便于查找，在插入过程中随机地将一些元素提升为高度为1~r的索引，以此来加快之后的操作。索引可以分为多层，一般而言，层数越高的索引个数越少。下面的图是一个跳表示例（隐去表头，上面的为高层） 为了方便下面对代码实现的说明，先给出各数据类型的定义。 template<typename T> class skiplist { private: static constexpr int MAX_LEVEL = 16; s
skiplist跳表C++实现
03-04
skiplist的C++实现，包含test程序
C++跳表实现
qq_34988341的博客
07-18 415
#pragma once #ifndef __SKIPLIST__H #define __SKIPLIST__H #include "skipNode.h" #include <vector> #include <math.h> #include <sstream> #include "dictionary.h" #include "illegalValue.h" /* * * * []------------->[]-------------
c++如何实现跳表（skiplist）
12-17
在C++中实现跳表，通常包括以下几个关键部分： 1. **节点定义**：每个节点包含一个键（Key）和一组指向下一个节点的指针数组。数组的大小表示节点所在的层数，例如`Node* next[1]`。在实际实现中，数组的大小可能...
c++如何实现跳表
08-18
C++实现跳表的知识点 跳表是一种随机化的数据结构，它允许快速查询一个有序连续元素的数据链表。跳跃列表的平均查找和插入时间复杂度都是O(log n)，优于普通队列的O(n)。性能上和红黑树，AVL树不相上下，但跳表的...
C++数据结构实现之SkipList.zip
06-04
跳表（Skip List）是一种随机化的数据结构，它在查找、插入和删除操作上的平均时间复杂度为O(log n)，并且实现相对简单。在C++中实现跳表可以帮助我们理解和应用这种高效的数据结构。跳表通常用于数据库索引、缓存...
C++【跳表】
芊樱烛渊的博客
12-29 1244
skiplist本质上也是一种查找结构，用于解决算法中的查找问题，跟平衡搜索树和哈希表的价值是一样的，可以作为key或者key/value的查找模型。skiplist是由William Pugh发明的，最早出现于他在1990年发表的论文《Skip Lists: A对细节感兴趣的同学可以下载论文原文来阅读。skiplist，顾名思义，首先它是一个list。实际上，它是在有序链表的基础上发展起来的。如果是一个有序的链表，查找数据的时间复杂度是O(N)。假如我们每相邻两个节点升高一层，增加一个指针。
C++ SkipList简单实现
xupeng1644的博客
11-11 2209
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...
跳跃表 C++实现
11-23
跳跃表的C++实现版本。 提供与红黑树的测试用例。
C++跳表的实现
03-03
用C++实现跳表的创建、添加、查找、删除等操作
跳表--C++实现
weixin_46120107的博客
03-04 1342
为何要学习跳表？为了快，为了更快，为了折磨自己.....
跳表C++实现(skip_list)
a245293206的博客
10-07 273
skip_list.h #pragma once #include <algorithm> #include <cstdlib> #include <iostream> namespace util { #ifdef DEBUG template <class T> void print(T arg) { std::cout << arg << " "; } template <typename... Args> voi
c++实现skip list
The Coding World
12-09 965
编程实例： #include #include #include #include #include #define maxLevel 12 struct Node { int key; int value; Node* forward[1]; }; struct skipList { int level; Node* head; }; class SkipList {
SkipList跳表C++实现
ThinkMo的专栏
05-24 2542
跳跃列表（也称跳表）是一种随机化数据结构，基于并联的链表，其效率可比拟于二叉查找树（对于大多数操作需要O(log n)平均时间）。
c++实现跳跃表
得也一天，失也一天！
02-20 751
直接上代码，拷贝过去就能运行 注释写在对应的代码里、 节点的定义 #ifndef _SKIP_NODE_H #define _SKIP_NODE_H #include <iostream> struct skipNode { int key; int value; int level; //size表示该节点存在的最高层数 skipNode* *next; //skipNo...
跳表c++实现
weixin_44866921的博客
10-07 547
原理：https://blog.csdn.net/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
韦东山imx6ullpro完全开发书册
最新发布
08-15
韦东山imx6ullpro完全开发书册
跳表(Skip List)实现原理详解
"跳表(Skip List)的实现原理和应用" 跳表是一种高效的数据结构，主要用来解决有序链表中查找特定值困难的问题。它的设计灵感来源于有序表，通过增加多级索引来加速查找过程，使得查找的时间复杂度降低到O(logn)。...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值