跳表 | 基本概念 | 代码实现

最新推荐文章于 2025-03-21 21:54:54 发布
最新推荐文章于 2025-03-21 21:54:54 发布
阅读量688 收藏 19
点赞数 22
分类专栏： 常见数据结构 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_63159859/article/details/143817760
版权

文章目录

1.跳表的基本概念

跳表的本质是一种查找结构，一般查找问题的解法分为两个大类：一个是基于各种平衡树，一个是基于哈希表，跳表比较的特殊，它独成一派。跳表是基于有序链表的基础上发展而来的，普通链表查找只能一个一个往下跳，而跳表能一次跳过好几个结点，这就是它查找效率高的原因。 例如：
如果只有一层那么查找就是逐个遍历，效率就是O(n)
在这里插入图片描述

如果为两个相邻结点添加第二层指向
在这里插入图片描述
甚至是添加第三层的指向
在这里插入图片描述
每层的结点个数呈现2:1的对应关系，查找就是从最高层开始，依次往下查找，这个过程类型二分查找，效率可以来到O(log n)。但是如果严格维持这种2:1的对应关系，插入删除节点都需要重新调整，插入删除效率直接就降到O(n)。所以跳表采用随机化结点的层数，来控制查找插入删除的时间复杂度近似为O(log n)。怎么计算可以参考博客。

2.跳表的结构

跳表的结点有多层，通过vector<SkiplistNode*> 来存储下一个结点的指针。初始化跳表时是带头结点的，它的层数要求是最高的，它开始只有它自己，默认给一层，后面插入的时候如果有结点的层数高于它，需要调整。

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

	SkiplistNode(int data,int level)
		:_data(data)
		,_nextV(level,nullptr)
	{}
};

class Skiplist
{
	typedef SkiplistNode Node;
private:
	Node* _head;
	int _maxLevel = 32;
	double _p = 0.25;

public:
	Skiplist()
	{
		_head = new Node(-1,1);
	}
};

int main()
{
	Skiplist list;	
	return 0;
}
3.跳表的增删改查

看看自己的代码有没有问题可以在leetcode上提交代码：题目链接
1）跳表的查找： 跳表中的元素是有序的，在理解跳表查找前先来看一下一个有序的单链表是如何查找元素的。
在这里插入图片描述
查找有序单链表，cur表示当前结点，如果cur的值data等于待查找的值target说明找到了。可如果cur 的下一个结点的值data大于target，说明target目标值不在链表中，或者是链表遍历到结尾还是找不到也说明target目标值不在链表中，这就是有序单链表的查找过程。
有了有序单链表的查找的基础，来看跳表的查找就简单了。
在这里插入图片描述
1、cur表示当前结点、next表示下一个结点、data表示结点的数据。
2、要从最高层找起，直到遍历到最低的那一层。
3、如果target 等于 cur的 data说明找到了。
4、如果target 大于 next 的 data，向右找。但是要保证next 不能为NULL。如找19而当前cur 的data是7，它的next 是NULL。不代表找不到，而是要到下一层找。
5、如果next的date 大于target 说明target可能在cur 和 next之间，往下一层找。

bool search(int target)
{
	Node* cur = _head;
	int level = cur->_nextV.size() -1;

	while(level >= 0)
	{
		if(cur->_nextV[level] && cur->_nextV[level]->_data < target)
		{
			cur = cur->_nextV[level];
		}
		else if(cur->_nextV[level] == nullptr || cur->_nextV[level]->_data > target)
		{
			level--;
		}
		else {return true;}
	}
	return false;
}

2）跳表的插入： 类比单链表的从中间的某个位置插入。需要找到前一个位置prev。跳表要找的是prevV，前结点指针列表。
在这里插入图片描述
1、找到prevV
2、创建一个结点newNode，先让newNode->_nextV[i] 逐个指向 prevV[i]->_nextV[i]指向的结点。再让prevV[i]->_nextV[i]指向newNode。
3、这里创建newNode层数是随机的，需要根据概率计算。这里参照radis中给定的概率和最大层数。
4、如果插入节点的层数高于头结点，需要调整头结点的层数。

vector<Node*> findPervV(int num)
{
	Node* cur = _head;
	int level = _head->_nextV.size() -1;
	vector<Node*> prevV(level + 1,nullptr);

	while(level >= 0)
	{			
		if(cur->_nextV[level] != nullptr && cur->_nextV[level]->_data < num)
		{
			cur = cur->_nextV[level];
		}
		else if(cur->_nextV[level] == nullptr || cur->_nextV[level]->_data >= num)
		{
			prevV[level] = cur;
			level--;
		}
	}
	return prevV;	
}

void add(int num)
{
	int n = randomLevel();

	int level = _head->_nextV.size() -1;
	vector<Node*> prevV = findPervV(num);
	
	// 调整头结点的层数
	if(n > _head->_nextV.size())
	{
		_head->_nextV.resize(n,nullptr);
		prevV.resize(n,_head);
	}

	Node* newNode = new Node(num,n);	
	for(int i = 0;i < n;i++)
	{			
		newNode->_nextV[i] = prevV[i]->_nextV[i];
		prevV[i]->_nextV[i] = newNode;
	}
}

int randomLevel()
{
	Node* cur = _head;
	srand(time(NULL));

	int level= 1;
	// rand的区间范围为[0,RAND_MAX]
	while(rand() <= RAND_MAX*_p && level < _maxLevel) { level++;}

	return level;
}

3）跳表的删除：
1、要到前结点列表prevV
2、根据当前结点的层数，循环指向prevV[i]->_nextV[i] = del->_nextV[i]

bool erase(int num)
{
	vector<Node*> prevV = findPervV(num);

	if(prevV[0]->_nextV[0] == nullptr || prevV[0]->_nextV[0]->_data != num)
	{
		return false;
	}
	else
	{
		Node* del = prevV[0]->_nextV[0];
		
		// 当前节点的层数
		for(int i = 0;i < del->_nextV.size();i++)
		{
			prevV[i]->_nextV[i] = del->_nextV[i];
		}
		delete del;

		int index = _head->_nextV.size() -1;
		
		// _head->_nextV[index] == nullptr说明最高结点删除了，调整头结点
		while (index >= 0) 
		{
			if(_head->_nextV[index] == nullptr) {index--;}
			else {break;}	
		}

		return true;
	}
}

4）跳表的打印： 这里按照单链表的思路打印，如果只看第一层那么跳表就像是有序的单链表。注意跳表是带头指针的，所以直接从_head->nextV[0]开始。

void print()
{
	Node* cur = _head->_nextV[0];

	while(cur != nullptr)
	{			
		cout << cur->_data << "->";	
		cur = cur->_nextV[0];
	}
	cout << "NULL" << endl;
}
4.完整代码
#include <vector>
#include <iostream>
#include <time.h>
#include <stdlib.h>


using namespace std;

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

	SkiplistNode(int data,int level)
		:_data(data)
		,_nextV(level,nullptr)
	{}
};


class Skiplist
{
	typedef SkiplistNode Node;
private:
	Node* _head;
	int _maxLevel = 32;
	double _p = 0.25;

public:
	Skiplist()
	{
		_head = new Node(-1,1);
	}

	bool search(int target)
	{
		Node* cur = _head;
		int level = cur->_nextV.size() -1;

		while(level >= 0)
		{
			if(cur->_nextV[level] && cur->_nextV[level]->_data < target)
			{
				cur = cur->_nextV[level];
			}
			else if(cur->_nextV[level] == nullptr || cur->_nextV[level]->_data > target)
			{
				level--;
			}
			else {return true;}
		}
		return false;
	}

	vector<Node*> findPervV(int num)
	{
		Node* cur = _head;
		int level = _head->_nextV.size() -1;
		vector<Node*> prevV(level + 1,nullptr);

		while(level >= 0)
		{			
			if(cur->_nextV[level] != nullptr && cur->_nextV[level]->_data < num)
			{
				cur = cur->_nextV[level];
			}
			else if(cur->_nextV[level] == nullptr || cur->_nextV[level]->_data >= num)
			{
				prevV[level] = cur;
				level--;
			}
		}
		return prevV;	
	}

	void add(int num)
	{
		int n = randomLevel();

		int level = _head->_nextV.size() -1;
		vector<Node*> prevV = findPervV(num);

		if(n > _head->_nextV.size())
		{
			_head->_nextV.resize(n,nullptr);
			prevV.resize(n,_head);
		}

		Node* newNode = new Node(num,n);	
		for(int i = 0;i < n;i++)
		{			
			newNode->_nextV[i] = prevV[i]->_nextV[i];
			prevV[i]->_nextV[i] = newNode;
		}
	}

	int randomLevel()
	{
		Node* cur = _head;
		srand(time(NULL));

		int level= 1;
		while(rand() <= RAND_MAX*_p && level < _maxLevel) { level++;}

		return level;
	}

	bool erase(int num)
	{
		vector<Node*> prevV = findPervV(num);

		if(prevV[0]->_nextV[0] == nullptr || prevV[0]->_nextV[0]->_data != num)
		{
			return false;
		}
		else
		{
			Node* del = prevV[0]->_nextV[0];

			for(int i = 0;i < del->_nextV.size();i++)
			{
				prevV[i]->_nextV[i] = del->_nextV[i];
			}
			delete del;

			int index = _head->_nextV.size() -1;

			while (index >= 0) 
			{
				if(_head->_nextV[index] == nullptr) {index--;}
				else {break;}	
			}

			return true;
		}
	}


	void print()
	{
		Node* cur = _head->_nextV[0];

		while(cur != nullptr)
		{			
			cout << cur->_data << "->";	
			cur = cur->_nextV[0];
		}
		cout << "NULL" << endl;
	}

};

int main()
{
	Skiplist list;	
	list.add(1);
	list.add(3);
	list.add(6);

	cout << list.search(6) << endl;

	list.erase(9);
	list.erase(6);

	cout << list.search(6) << endl;

	list.print();
	return 0;
}
跳表详解以及Java实现
qq_44957574的博客
04-25 1879
redis zset原理——跳表数据结构详解，使用Java代码实现。
java跳表实现
11-06
在Java中实现跳表，我们需要理解其基本原理并掌握相关的数据结构知识。 跳表的核心概念是链表和随机化。首先，我们定义一个跳表节点（SkipListNode），它通常包含两个部分：值（value）和指向下一个节点的指针数组...
跳表介绍
zhangbinalan的专栏
07-17 866
跳表介绍
跳表简单介绍
wwxy1995的博客
08-30 214
跳表是为了让链表的查找更快而诞生的一种数据结构 跳表在链表的基础上，向上建立索引 跳表的查找从最上层开始，逐层向下进行查找 跳表的插入： 需要先在链表中插入数据，再去跟新索引。 跳表的上层节点个数一般是下层节点个数的1/2 跳表插入和删除的时间复杂近似为O(logN） ...
Skip List--跳表（全网最详细的跳表文章没有之一）
最新发布
宋发元
03-21 437
跳表是可以实现二分查找的有序链表；每个元素插入时随机生成它的level；最底层包含所有的元素；如果一个元素出现在level(x)，那么它肯定出现在x以下的level中；每个索引节点包含两个指针，一个向下，一个向右；（笔记目前看过的各种跳表源码实现包括Redis 的zset 都没有向下的指针，那怎么从二级索引跳到一级索引呢？留个悬念，看源码吧，文末有跳表实现源码）跳表查询、插入、删除的时间复杂度为O(log n)，与平衡二叉树接近；
跳表
weixin_30897079的博客
04-21 287
有序表的搜索 考虑一个有序表：从该有序表中搜索元素 < 23, 43, 59 > ，需要比较的次数分别为 < 2, 4, 6 >，总共比较的次数为 2 + 4 + 6 = 12 次。有没有优化的算法吗? 链表是有序的，但不能使用二分查找。类似二叉搜索树，我们把一些节点提取出来，作为索引。得到如下结构： 提取出来作为一级索引，这样搜索的时候就可以减少比较次数了。...
探索跳表数据结构及其完整代码实现
在计算机科学和信息技术领域，数据结构是指组织数据的一种方式...通过以上分析和代码示例，我们对跳表的基本概念、操作原理和实现方法有了较全面的理解。跳表作为一种高效的数据结构，在实际应用中有着广泛的应用价值。
跳表完整代码
03-17
在本文中，我们将深入探讨跳表的概念、工作原理、实现细节以及其在实际应用中的优势。 跳表（Skip List）由P. P. Mancini于1990年提出，它的设计灵感来源于随机化二叉搜索树。跳表是一种概率型数据结构，通过随机...
算法文档无代码线段跳表-跳表的一个拓展
04-15
标题“算法文档无代码线段跳表-跳表的一个拓展”暗示了文档内容是关于跳表这一数据结构的深入探讨，并且特别指出这是一个拓展性研究，但不包含具体代码实现。这说明文档是面向那些已经对跳表有基本了解的读者，意在...
17 | 跳表：为什么Redis一定要用跳表来实现有序集合？
liyf2的博客
10-18 286
上两节我们讲了二分查找算法。当时我讲到，因为二分查找底层依赖的是数组随机访问的特性，所以只能用数组来实现。如果数据存储在链表中，就真的没法用二分查找算法了吗？ 实际上，我们只需要对链表稍加改造，就可以支持类似“二分”的查找算法。我们把改造之后的数据结构叫做跳表（Skip list），也就是今天要讲的内容。 跳表这种数据结构对你来说，可能会比较陌生，因为一般的数据结构和算法书籍里都不怎么会讲。但是它确实是一种各方面性能都比较优秀的动态数据结构，可以支持快速地插入、删除、查找操作，写起来也不复杂，甚至可以替代红
数据结构之跳表
wang0907的博客
09-29 571
跳表，链表版本的二分查找，具备高效的数据插入，查找，删除，范围查询等优点。是一种高效的数据结构。本文一起来看下。我们知道数组具备随机访问的特性，因此使用其可以很方便的实现二分查找算法，但是链表是不支持随机访问的，但是如果我们对链表增加索引，让其支持随机访问（这里的随机是一定程度上的随机，也可以说是假随机），那么这种经过了一定改造之后的链表，我们就可以称之为跳表。接下来看下这个索引是怎么加的，又是如何实现高效的查找的，假设我们有一个链表，如下:此时如果是我们要查找16,则需要查找10个节点，为。
数据结构之跳表（skip list）
Nemo的博客
02-17 1083
众所周之，二分查找依赖的是数组的随机仿问特性。如果是用链表去存储数据，二分查找就没法使用了吗？实际上，只要对链表稍加改造，就可以支持二分查找。 对于一个单链表来讲，即使链表中存储的数据是有序的，如果我们要查找某个数据，也只能从头到尾遍历链表，这样查找效率就很低，时间复杂度就很高，是O(n). 那么怎么提高查找效率呢？如果从原始链表中每两个结点中抽取一个作为一个索引，所有的索引组成一个索引层。如下图所示 假如现在需要查找数据8，那么第一层索引的比较顺序为1，3，5，7，9. 发现7比8小，9比.
两个for做数据插入_数据结构与算法——跳表
weixin_39554021的博客
11-24 101
什么是跳表跳表全称为跳跃列表，它允许快速查询，插入和删除一个有序连续元素的数据链表。跳跃列表的平均查找和插入时间复杂度都是O(logn)。快速查询是通过维护一个多层次的链表，且每一层链表中的元素是前一层链表元素的子集（见右边的示意图）。一开始时，算法在最稀疏的层次进行搜索，直至需要查找的元素在该层两个相邻的元素中间。这时，算法将跳转到下一个层次，重复刚才的搜索，直到找到需要查找的元素为止。一张跳跃...
高阶数据结构——跳表
weixin_74310945的博客
08-12 713
skiplist本质上也是一种查找结构，用于解决算法中的查找问题，跟平衡搜索树和哈希表的价值是一样的，可以作为key或者key/value的查找模型。skiplist，顾名思义，首先它是一个list。实际上，它是在有序链表的基础上发展起来的。如果是一个有序的链表，查找数据的时间复杂度是O(N)。每相邻两个节点升高一层，增加一个指针，让指针指向下下个节点。
数据结构与算法-跳表详解
欢迎朋友，我是一名十多年开发经验的新手，希望多多指教。
06-06 1186
我们知道如果一个数组是有序的，查询的时候可以使用二分法进行查询，时间复杂度可以降到 O(logn) ，但如果链表是有序的，我们仍然是从前往后一个个查找，这样显然很慢，这个时候我们可以使用跳表（Skip list），跳表就是多层链表，每一层链表都是有序的，最下面一层是原始链表，包含所有数据，从下往上节点个数逐渐减少。
跳表的实现和复杂度分析
CLL_124的博客
06-03 1584
大学生作业，参考许多大佬博客[感恩]。(侵删)参考资料[1]:SkipList 跳表[2]:跳表（Skip List）[3]:C++面试：跳表[4]:查找算法-跳跃表(SkipList)入门及复杂度分析[5]:跳表跳表，又叫做跳跃表、跳跃列表，在有序链表的基础上增加了“跳跃”的功能。跳表在原来的有序链表上加上了多级索引，通过索引来快速查找；可以支持快速的删除、插入和查找操作。跳表实际上是一种增加了前向指针的链表，是一种随机化的数据结构。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值