跳表 笔记

最新推荐文章于 2021-03-06 12:14:39 发布
最新推荐文章于 2021-03-06 12:14:39 发布
阅读量271 收藏 4
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43736572/article/details/105507063
版权

跳表

在一个有n个元素的有序链表中，查找一个元素的时间复杂度为O(n)，但如果把所有第偶数个元素取出来形成一个上级链表，那么复杂度就变成了O(n/2)。如果再在这个上级链表中，把所有第偶数个元素取出形成一个再上级链表，重复这个操作，直到最上级链表中只有一个元素，此时变相地形成了一棵二叉树，复杂度也逐级地降为了O(logn)。

在实际的链表中，并不是固定地取第偶数个元素作为上级链表的元素，而是通过一个概率来分配，且一个元素的级数在其插入时动态形成。

设最底级的链表为0级链表，对于一个新插入的元素来说，从第0级开始，以一个概率P来决定它是否是上一级的元素，这个概率P同时也等于上一级链表元素个数与下一级链表元素个数的比值。具体的说，先产生一个0-1之间的随机数，那么这个随机数小于等于概率P的概率就是P。所以，如果产生的随机数<=P，那么这个元素就也属于上一级链表，即1级链表，然后继续生成一个0-1之间的随机数，如果随机数<=P，这个元素的级数继续增加，即2级链表。但如果随机数>P，那么这个元素的级数就停在该级链表上，停止增加，此时这个元素的级也就被成功分配。

需要注意的是，虽然概率很小，但是在极其幸运的时候，一个元素的级数可能很大，这并不利于跳表的性能。所以，在实现跳表时，要设置一个最大级数maxLevel，最大值为log1/p(n)-1。

根据课程要求，实现的是字典的跳表，所以代码实现时，元素是通过pair型构建的。

代码实现

节点

数据域+指针域+构造函数

需要注意的是，因为一个元素会出现在多级链表中，所以这里的指针域是一个指针数组，注意指针数组的空间大小要大于元素所属的级数，因为每个元素都包含在0级链表中。指针数组里记录的是每一级的指向下一个节点的指针，但是在创建节点的时候只需要分配空间就好，实际的指针存储在插入时实现。

template <class K,class E>
struct skipNode
{
	typedef pair<const K,E> pairType;
	
	pairType element;	//存储数对 
	skipNode<K,E> **next;	//指针数组 
	
	skipNode(const pairType& thePair,int size)
		:element(thePair){next=new skipNode<K,E>*[size];} 
};
构造函数

在生成跳表时，要确定的参数：
概率P即prob；
跳表的最大关键字largeKey，最大关键字存放在头、尾节点用来简化查找；
跳表允许的最大元素个数maxPairs，因为程序中使用最大元素个数来代替计算最大级数的公式中的n，所以跳表中的元素个数不超过最大元素个数可以保持较好性能；

最大级数maxLevel通过公式log1/p-1来获得。
头节点headerNode需要能够存放每级链表的指针大小的空间，所以其指针数组大小为maxLevel+1；但是尾节点tailNode不需要指针域，所以尾节点的数组大小为0。last数组是用来存储查找元素时的每一级链表的最后位置，所以大小也是最大级数+1。
cutOff是用来辅助确定元素的级数的。这里用prob*RAND_MAX来赋值，而在级的分配函数中，用cutOff和rand()比较，实际就是比较一个0-1的随机数和概率prob。

初始时，跳表为空，所以头节点的每一级指针都指向尾节点。

template<class K,class E>
skipList<K,E>::skipList(K largeKey,int maxPairs,float prob)
{//构造函数，关键字小于largeKey且数对个数size最多为maxPairs,0<prob<1 
	cutOff=prob*RAND_MAX;	//产生随机小数  RAND_MAX <stdlib.h> 
	maxLevel=(int)ceil(logf((float)maxPairs)/logf(1/prob))-1;
	levels=0;	//初始化级数 
	dSize=0;	//跳表中已有的元素个数
	tailKey=largeKey;
	
	//生成头节点、尾节点、数组last
	pair<K,E> tailPair;
	tailPair.first=tailKey;
	
	headerNode=new skipNode<K,E>(tailPair,maxLevel+1);
	tailNode=new skipNode<K,E>(tailPair,0); 
	last=new skipNode<K,E>*[maxLevel+1];
	
	//链表为空时，任意级链表中的头节点都指向尾节点 
	for(int i=0;i<=maxLevel;i++)
		headerNode->next[i]=tailNode; 
}
析构函数
template<class K,class E>
skipList<K,E>::~skipList()
{
	delete headerNode;
	delete tailNode;
	delete []last;
}
查找函数find

实现查找元素的操作。先与跳表的最大关键字比较，只有小于最大关键字的元素才能在跳表中被找到。然后从头节点开始，从最上级链表(levels，当前最大的非空链表)开始往下搜。在每一级链表找最大的小于查找元素的节点，那么当跳出while循环时已经遍历到了0级链表，如果元素存在，那么beforeNode->next[0]就是查找元素的节点，但如果beforeNode的next[0]不等于查找元素，说明该元素不存在。

template <class K,class E>
void skipList<K,E>::find(const K& b)	//b为查找树对的关键字 
{
	if(b>=tailKey)	//不存在
	{
		cout<<"-1\n"; 
		return;	
	} 
	//beforeNode是关键字为b的节点的前一个
	skipNode<K,E>* beforeNode= headerNode;
	for(int i=levels;i>=0;i--)	//从上级链表到下级链表  levels 当前最大非空链表 
	{//跟踪i级链表指针
		while(beforeNode->next[i]->element.first<b)
		{
			//cout<<beforeNode->next[i]->element.first<<endl;
		 	beforeNode=beforeNode->next[i];			
		}

	} 	
	//检查下一个节点的关键字是否为b 
	if(beforeNode->next[0]->element.first==b)
		cout<<beforeNode->next[0]->element.second<<"\n";		
	else
	{
		cout<<"-1\n";	//无匹配数对 
		return;
	}
}
查找函数search

插入和删除之前，都要先找到元素的位置，所以都需要使用到查找函数。

从头节点开始，从最上级链表(levels，当前最大的非空链表)开始往下搜。在每一级链表找最大的小于查找元素的节点，在last数组中记录这个节点指针，那么当跳出while循环时已经遍历到了0级链表，而beforeNode的next[0]就是查找的元素。

template <class K,class E>
skipNode<K,E>* skipList<K,E>::search(const K& theKey) const
{//搜索theKey，并保存每一级链表最后查看的节点位置保存在数组last中
	//返回可能含有theKey的节点位置
	//指针beforeNode，指向可能与theKey匹配节点的前一个节点
	skipNode<K,E>* beforeNode=headerNode;
	for(int i=levels;i>=0;i--)
	{
		while(beforeNode->next[i]->element.first<theKey)
		 	beforeNode=beforeNode->next[i];
		last[i]=beforeNode;
	}
	return beforeNode->next[0];
	
}
级的分配

在插入元素时，要在插入前，先实现对新元素的级的分配操作。

这里的rand()返回的是一个0-RAND_MAX之间的随机数，而这个随机数小于等于cutOff的概率就是prob。

template <class K,class E>
int skipList<K,E>::level() const
{//产生一个随机级号，该级号<=maxLevel
	int lev=0;
	while(rand()<=cutOff)
		lev++;
	return(lev<=maxLevel)?lev:maxLevel; 	
}
插入函数

先通过查找函数search看插入元素是否已经存在在跳表中了，如果存在，只做更新操作，如果不存在，再做插入操作。

首先通过level()函数分配新元素的级theLevel，如果新元素的级大于当前最大的非空链表级数，那么当前最大的非空链表级数要被更新，还需要维护last数组，如果不对last[theLevel]赋值，可能会指向非法内存。最后，进行节点的插入操作，即newNode->next[i]=last[i]->next[i]，last[i]->next[i]=newNode，不要忘了跳表中的元素数量要加一。

template <class K,class E>
void skipList<K,E>::insert(const pair<const K,E>& thePair)
{
	if(thePair.first>=tailKey)
	{
		cout<<"关键值太大 ，异常处理"<<endl; 
	} 
	//查看theKey是否存在 
	skipNode<K,E>* theNode=search(thePair.first);
	//theKey已存在 
	if (theNode->element.first==thePair.first)
	{//更新数对 
    	theNode->element.second=thePair.second;
    	return;
	} 
	//不存在，确定新节点的级 
	int theLevel=level();		//新节点的级
	if (theLevel>levels)	//使theLevel<=levels+1  levels当前最大非空链表 
	{
    	theLevel=++levels;		//theLevel=levels+1 
    	last[theLevel]=headerNode;	//最新的一级只有headerNode有指针 
	}
	//产生新节点，并将新节点插入在theNode后面 
	skipNode<K,E>* newNode=new skipNode<K,E>(thePair,theLevel+1);
	for (int i=0;i<=theLevel;i++)
	{//插入到第i级链 
    	newNode->next[i]=last[i]->next[i];
    	last[i]->next[i]=newNode;	//维护last[i] 
	}
	dSize++;
	return;
}
删除函数

同样的，先判断元素的合法性，再通过search函数寻找删除函数的位置，因为search函数并没有比较元素的值，它返回的只是一个如果该元素存在，那么这个元素理论上的位置，所以在删除函数中，还需要判断返回的节点是不是要删除的节点。

如果是，那么与插入函数类似的，对每一级做删除节点的操作，即last[i]->next[i]=theNode->next[i]，但前提是，theNode是要删除的节点。

最后，判断删除节点后最上级链表是否为空，如果为空，那么levels需要被修改。别忘了修改dsize。

template <class K,class E>
void skipList<K,E>::erase(const K& theKey)
{//删除关键字为theKey的数对
	if(theKey>=tailKey)	//关键字太大
	{
		cout<<"-1\n"; 
		return;	
	} 
	//查看是否有匹配的数对
	skipNode<K,E>* theNode=search(theKey);
	if(theNode->element.first!=theKey)		//不匹配 
	{
		cout<<"-1\n"; 
		return;	
	} 
	E ele=theNode->element.second;
	//维护last数组 
	for(int i=0;i<=levels&&last[i]->next[i]==theNode;i++)
		last[i]->next[i]=theNode->next[i];
	//更新链表级
	while(levels>0&&headerNode->next[levels]==tailNode)
		levels--;
	delete theNode;
	dSize--; 
	cout<<theKey<<" "<<ele<<"\n";
	return;
}
删除最值函数

先从0级链表获取最大值/最小值，然后类似于删除函数的做法，删除最值即可。

//删除最小值
template <class K,class E>
void skipList<K,E>::eraseMin()	//headerNode的下一个 
{
	skipNode<K,E>* theNode=headerNode->next[0];	//要删除的数对
	K theKey=theNode->element.first; 
	
	if(theNode==tailNode)		//不匹配 
	{
		cout<<"-1\n"; 
		return;	
	} 
	E ele=theNode->element.second;
	//维护last数组，指向后一个 
	for(int i=0;i<=levels&&last[i]->next[i]==theNode;i++)
		last[i]->next[i]=theNode->next[i];
	//更新链表级
	while(levels>0&&headerNode->next[levels]==tailNode)
		levels--;
	delete theNode;
	dSize--; 
	cout<<theKey<<" "<<ele<<"\n";
	return;
}
//删除最大值
template <class K,class E>
void skipList<K,E>::eraseMax()
{
	skipNode<K,E>* theNode=headerNode;
	for(int i=levels;i>=0;i--)
	{
		while(theNode->next[i]->element.first<tailKey)
		 	theNode=theNode->next[i];
		last[i]=theNode;
	}
	K theKey=theNode->element.first;
	E ele=theNode->element.second;
	//维护last数组 
	for(int i=0;i<=levels&&last[i]->next[i]==theNode;i++)
		last[i]->next[i]=theNode->next[i];
	//更新链表级
	while(levels>0&&headerNode->next[levels]==tailNode)
		levels--;
	delete theNode;
	dSize--; 
	cout<<theKey<<" "<<ele<<"\n";
	return;
}

复杂度分析

跳表的优势就在于查找、插入、删除的复杂度都是O(logn)，最坏性能为O(n)，媲美二叉树，但其最坏性能只与概率有关系，且其概率很低。

完整代码

#include <iostream>
#include <algorithm>	//pair头文件 
#include <stdlib.h>		//RAND_MAX头文件 
#include <string>
#include <math.h>
using namespace std;

template <class K,class E>
struct skipNode
{
	typedef pair<const K,E> pairType;
	
	pairType element;	//存储数对 
	skipNode<K,E> **next;	//指针数组 
	
	skipNode(const pairType& thePair,int size)
		:element(thePair){next=new skipNode<K,E>*[size];} 
};

template <class K,class E>
class skipList
{
	public:
		skipList(K, int maxPairs=10000, float prob=0.5);
		~skipList();
		void find(const K& b);	//b查找元素关键字，输出元素值，不存在输出-1 
		void insert(const pair<const K,E>& thePair);	//插入<b,c>，不输出 
		void erase(const K& theKey);	//b删除元素关键字，不存在输出-1 
		void eraseMin();	//输出最小元素关键字和值，并删除 
		void eraseMax();	//输出最大元素关键字和值，并删除 		
	private:
		float cutOff;	//确定层数
/**/	int level() const;	//产生级数 
		int levels;	//当前最大的非空链表 
		int dSize;	//字典的数对个数 
		int maxLevel;	//语序的最大链表层数 
		skipNode<K,E>* search(const K&) const; 
		K tailKey;	//最大关键字 
		skipNode<K,E>* headerNode;	//头节点指针 
		skipNode<K,E>* tailNode;	//尾节点指针 
		skipNode<K,E>** last; 	//last[i]表示i层的最后节点 
};
template<class K,class E>
skipList<K,E>::skipList(K largeKey,int maxPairs,float prob)
{//构造函数，关键字小于largeKey且数对个数size最多为maxPairs,0<prob<1 
	cutOff=prob*RAND_MAX;	//产生随机小数  RAND_MAX <stdlib.h> 
	maxLevel=(int)ceil(logf((float)maxPairs)/logf(1/prob))-1;
	levels=0;	//初始化级数 
	dSize=0;
	tailKey=largeKey;
	
	//生成头节点、尾节点、数组last
	pair<K,E> tailPair;
	tailPair.first=tailKey;
	
	headerNode=new skipNode<K,E>(tailPair,maxLevel+1);
	tailNode=new skipNode<K,E>(tailPair,0); 
	last=new skipNode<K,E>*[maxLevel+1];
	
	//链表为空时，任意级链表中的头节点都指向尾节点 
	for(int i=0;i<=maxLevel;i++)
		headerNode->next[i]=tailNode; 
} 
template<class K,class E>
skipList<K,E>::~skipList()
{
	delete headerNode;
	delete tailNode;
	delete []last;
}
template <class K,class E>
void skipList<K,E>::find(const K& b)	//b为查找树对的关键字 
{
	if(b>=tailKey)	//不存在
	{
		cout<<"-1\n"; 
		return;	
	} 
	//beforeNode是关键字为b的节点的前一个
	skipNode<K,E>* beforeNode= headerNode;
	for(int i=levels;i>=0;i--)	//从上级链表到下级链表  levels 当前最大非空链表 
	{//跟踪i级链表指针
		while(beforeNode->next[i]->element.first<b)
		{
			//cout<<beforeNode->next[i]->element.first<<endl;
		 	beforeNode=beforeNode->next[i];			
		}

	} 	
	//检查下一个节点的关键字是否为b 
	if(beforeNode->next[0]->element.first==b)
		cout<<beforeNode->next[0]->element.second<<"\n";		
	else
	{
		cout<<"-1\n";	//无匹配数对 
		return;
	}
}
template <class K,class E>
skipNode<K,E>* skipList<K,E>::search(const K& theKey) const
{//搜索theKey，并保存每一级链表最后查看的节点位置保存在数组last中
	//返回可能含有theKey的节点位置
	//指针beforeNode，指向可能与theKey匹配节点的前一个节点
	skipNode<K,E>* beforeNode=headerNode;
	for(int i=levels;i>=0;i--)
	{
		while(beforeNode->next[i]->element.first<theKey)
		 	beforeNode=beforeNode->next[i];
		last[i]=beforeNode;
	}
	return beforeNode->next[0];
	
} 
template <class K,class E>
int skipList<K,E>::level() const
{//产生一个随机级号，该级号<=maxLevel
	int lev=0;
	while(rand()<=cutOff)
		lev++;
	return(lev<=maxLevel)?lev:maxLevel; 	
}
template <class K,class E>
void skipList<K,E>::insert(const pair<const K,E>& thePair)
{
	if(thePair.first>=tailKey)
	{
		cout<<"关键值太大 ，异常处理"<<endl; 
	} 
	//查看theKey是否存在 
	skipNode<K,E>* theNode=search(thePair.first);
	//theKey已存在 
	if (theNode->element.first==thePair.first)
	{//更新数对 
    	theNode->element.second=thePair.second;
    	return;
	} 
	//不存在，确定新节点的级 
	int theLevel=level();		//新节点的级
	if (theLevel>levels)	//使theLevel<=levels+1  levels当前最大非空链表 
	{
    	theLevel=++levels;		//theLevel=levels+1 
    	last[theLevel]=headerNode;	//最新的一级只有headerNode有指针 
	}
	//产生新节点，并将新节点插入在theNode后面 
	skipNode<K,E>* newNode=new skipNode<K,E>(thePair,theLevel+1);
	for (int i=0;i<=theLevel;i++)
	{//插入到第i级链 
    	newNode->next[i]=last[i]->next[i];
    	last[i]->next[i]=newNode;	//维护last[i] 
	}
	dSize++;
	return;
}
template <class K,class E>
void skipList<K,E>::erase(const K& theKey)
{//删除关键字为theKey的数对
	if(theKey>=tailKey)	//关键字太大
	{
		cout<<"-1\n"; 
		return;	
	} 
	//查看是否有匹配的数对
	skipNode<K,E>* theNode=search(theKey);
	if(theNode->element.first!=theKey)		//不匹配 
	{
		cout<<"-1\n"; 
		return;	
	} 
	E ele=theNode->element.second;
	//维护last数组 
	for(int i=0;i<=levels&&last[i]->next[i]==theNode;i++)
		last[i]->next[i]=theNode->next[i];
	//更新链表级
	while(levels>0&&headerNode->next[levels]==tailNode)
		levels--;
	delete theNode;
	dSize--; 
	cout<<theKey<<" "<<ele<<"\n";
	return;
}
template <class K,class E>
void skipList<K,E>::eraseMin()	//headerNode的下一个 
{
	skipNode<K,E>* theNode=headerNode->next[0];	//要删除的数对
	K theKey=theNode->element.first; 
	
	if(theNode==tailNode)		//不匹配 
	{
		cout<<"-1\n"; 
		return;	
	} 
	E ele=theNode->element.second;
	//维护last数组，指向后一个 
	for(int i=0;i<=levels&&last[i]->next[i]==theNode;i++)
		last[i]->next[i]=theNode->next[i];
	//更新链表级
	while(levels>0&&headerNode->next[levels]==tailNode)
		levels--;
	delete theNode;
	dSize--; 
	cout<<theKey<<" "<<ele<<"\n";
	return;
}
template <class K,class E>
void skipList<K,E>::eraseMax()
{
	skipNode<K,E>* theNode=headerNode;
	for(int i=levels;i>=0;i--)
	{
		while(theNode->next[i]->element.first<tailKey)
		 	theNode=theNode->next[i];
		last[i]=theNode;
	}
	K theKey=theNode->element.first;
	E ele=theNode->element.second;
	//维护last数组 
	for(int i=0;i<=levels&&last[i]->next[i]==theNode;i++)
		last[i]->next[i]=theNode->next[i];
	//更新链表级
	while(levels>0&&headerNode->next[levels]==tailNode)
		levels--;
	delete theNode;
	dSize--; 
	cout<<theKey<<" "<<ele<<"\n";
	return;
}

int main()
{
	int n;
	long m;
	cin>>n>>m;
	skipList<long,string> sl(1000000001);
	for(int i=0;i<n;i++)
	{
		int p;
		string s;
		cin>>p>>s;
		pair<int,string> t={p,s};
		sl.insert(t);
	}
	for(long i=0;i<m;i++)
	{
		int a,b;
		string c;
		pair<int,string> tmp;
		cin>>a;
		switch(a)
		{
			case 1:
				//查找 
				cin>>b;
				sl.find(b);
				break;
			case 2:
				//插入 
				cin>>b>>c;
				tmp.first=b;
				tmp.second=c;
				sl.insert(tmp);
				break;
			case 3:
				//删除 
				cin>>b;
				sl.erase(b);
				break;
			case 4:
				//删除最小元素 
				sl.eraseMin();
				break;
			case 5:
				//删除最大元素 
				sl.eraseMax();
				break;
		}
	}
	return 0;
}
wtttcl
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
跳表
Lzc的博客
07-25 3554
跳表(skip list) 对标的是平衡树(AVL Tree)，是一种 插入/删除/搜索 都是 O(log n) 的数据结构。它最大的优势是原理简单、容易实现、方便扩展、效率更高。因此在一些热门的项目里用来替代平衡树，如 redis, leveldb 等。 跳表的基本思想 首先，跳表处理的是有序的链表（一般是双向链表，下图未表示双向），如下： 这个链表中，如果要搜索一个数，需要从头到尾比较每个元...
跳表实现
qq_43324189的博客
03-05 685
要求 实现并分析跳表结构 构造并实现跳表ADT，跳表ADT包括如下操作： 初始化跳表 查找跳表内是否存在元素x 向跳表插入元素x 删除跳表内元素x，若不存在则抛出异常 删除跳表内关键字最小的元素 删除跳表内关键字最大的元素 其他根据需要实现，注意数据的可访问性 格式 输入格式 输入包含 1+n+m 行数据 第一行包含两个数字 n, m (0 \leq n \leq 1000, 0 \leq m \...
matlab 中常用函数
weixin_42007145的博客
03-06 1176
matlab 中产生随机数的函数 rand（m,n) 或 rand( [m,n] ) 产生0到1间均匀分布的m行n列矩阵 rand(size(A)) 产生和矩阵A相同尺寸的随机矩阵 randi randi 生成均匀分布的伪随机整数 randi (max) 生成一个位于[1,max]的随机整数，是一个数（闭区间） randi (max,m,n) 生成m行n列位于[1,max]的随机整数（闭区间） randi([min,max],m,n) 生成m行n列位于[min,
左神算法笔记（二十三）——跳表
02-09 448
跳表可以认为同样包含key和value，可以完成任何红黑树包含的操作。同时代价也是O(logN)。 但是底层不是数结构，比较魔性，但是也好实现。 跳表思想： key包含多少层，不是由key本身决定的，而是随机的。随机函数只包含0和1，roll出1时最少层数确定，第几次roll出1，则系统最小有几层。 数据插入：重新roll，得到该key的层数，此时从高层开始计算数据是否应该插入该位置，算得位置后，...
跳表的实现插入删除搜索算法详解
FreeeLinux's blog
11-10 4559
跳表久闻其名，以前写过AVL树，红黑树，都是平衡结构。但是跳表呢，它不是树形结构，它是通过链表实现的。 我们知道，在链表中查找一个元素的时间复杂度是O(n)。 在一个有序链表中，我们如果在链表中部额外增加一个结点，那么查找某个元素的次数将会是 n/2+1 次。类似于二分查找。 有了这个思想，那么现在就可以实行跳跃表了。 先看图，有个印象，再解释。 如图，每个结点都有一个指
左（进阶）算法----数据结构自设计 / 跳表
多多
07-08 690
设计可以变更的缓存结构：思路：设计结构  map---储存对应的位置 + 双向链表---维持优先级还有size的限制 ----如果超过个数限制 ---则将头节点删除 并 从中找到map对应的记录（因为节点中含有map中的key)将新加入节点连在双向链表后面即可~代码实现：设计的缓存结构：注意：map  中  存值 具体和数值类型有关map 中  存放 基础类型  则就是具体的值          ...
clickhouse学习笔记
09-14
以下是对 ClickHouse 学习笔记的详细解析： ### 1. ClickHouse 特点 1.1.1 **列式存储**：ClickHouse 采用列式存储方式，相比传统的行式存储，对于聚合查询和分析性能有显著提升，因为列式存储可以快速读取特定列...
redis 学习笔记
07-18
- 有序集合：通过使用跳表（Skip List）实现，支持高效的插入、删除和范围查询操作。 2. 性能： - 哈希算法：Redis 使用 MurmurHash2 32 位算法，保证了哈希的高效性和均匀分布。在字典操作中，当字典的 `used/...
笔记-5、并发容器1
08-08
这两个容器基于跳表（Skip List）数据结构，跳表是一种可以快速查找的有序数据结构，通过多级索引实现高效的查找、插入和删除操作。与ConcurrentHashMap类似，它们同样提供了线程安全的并发操作。 总结，...
ACM实用笔记，小白入.doc
05-15
8. **跳表**：一种概率数据结构，通过增加多级索引来优化搜索性能。 9. **图**：由顶点和边组成的数据结构，用于模拟各种关系网络。 10. **Trie 树**：又称前缀树，用于高效存储和检索字符串。 #### 三、Java编程...
Leetcode刷题笔记-大厂面试突破集
08-15
1206题《设计跳表》则是数据结构实现题，涉及到高效查找和插入的问题。 双指针技巧在许多题目中都有应用，如1021题《删除最外层的括号》和1089题《最长定差子序列》。1022题《从根到叶的二进制数之和》考察的是树的...
python中np.random.rand() 函数
热门推荐
Eeeeearl的博客
04-08 1万+
np.random.rand()函数
[C++]跳表
mzman的博客
01-02 436
跳表是一个随机化的数据结构，实质就是一种可以进行二分查找的有序链表。跳表是有序链表，当一个新节点加入跳表时，会按照一定的概率分布获得一个索引等级，高等级的产生几率小于低等级。每个节点有一组next指针，各个等级的节点构成各个等级的链表，每个节点不同的next指针用于不同等级的链表，高等级的节点也都会出现在低等级的链表中，即高等级链表是低等级链表的子集。 例如二分跳表，所有节点都出现在0级链表中，而只有1/2的节点出现在1级链表中，有1/8的节点出现在2级链表中……设相邻等级高等级与低等级出现率的比值为p,(
左神基础算法笔记-一
一盏小灯下
09-05 421
1. 认识时间复杂度常数时间的操作：一个操作如果和数据量没有关系，每次都是固定的时间内完成的操作，叫做常数操作。 时间复杂度为一个算法流程中，常数操作数量的指标。常用O（读作big O）来表示。具体来说，在常数操作数量的表达式中，只要高阶项，不要低阶项，也不要高阶项的系数，剩下的部分记为f(N)，那么时间复杂度为O(f(N))。 评价一个算法流程的好坏，先看时间...
数据结构进阶篇-跳表
weixin_33966365的博客
05-15 268
大家想必都知道，数组和链表的搜索操作的时间复杂度都是O(N)的，在数据量大的时候是非常耗时的。对于数组来说，我们可以先排序，然后使用二分搜索，就能够将时间复杂度降低到O(logN)，但是有序数组的插入是一个O(N)级别的操作。而链表的插入性能相对优秀，却不能使用二分搜索快速查询。那么是否有一种数据结构，即能够像链表一样快速插入数据，又支持类似于二分搜索这样的查询算法呢？答案是肯定的。William...
查找：跳表
jinzhao1993的博客
01-16 1100
跳跃表定义： 一个有序列表，其中每个节点包含不定数量的链接，节点中的第i个链接构成的单向链表跳过含有少于i个链接的节点。
跳表java代码实现，根据左神视频改进
赶作业的suda的博客
05-07 242
跳表的具体插入、删除过程，网上都有的，大家可以自行查阅。 下面是观看左神算法之后，自己实现的code。 欢迎大家批评指正。 import java.util.ArrayList; public class SkipListTest { public static void main(String[] args) { SkipList list = new SkipList...
农情采集系统手机app.zip农情采集系统手机app.zip
最新发布
08-25
农情采集系统手机app.zip农情采集系统手机app.zip农情采集系统手机app.zip农情采集系统手机app.zip农情采集系统手机app.zip农情采集系统手机app.zip农情采集系统手机app.zip农情采集系统手机app.zip农情采集系统手机app.zip农情采集系统手机app.zip农情采集系统手机app.zip农情采集系统手机app.zip农情采集系统手机app.zip农情采集系统手机app.zip农情采集系统手机app.zip农情采集系统手机app.zip农情采集系统手机app.zip农情采集系统手机app.zip农情采集系统手机app.zip农情采集系统手机app.zip农情采集系统手机app.zip农情采集系统手机app.zip农情采集系统手机app.zip农情采集系统手机app.zip农情采集系统手机app.zip农情采集系统手机app.zip农情采集系统手机app.zip农情采集系统手机app.zip农情采集系统手机app.zip农情采集系统手机app.zip农情采集系统手机app.zip农情采集系统手机app.zip农情采集系统手机app.zip农情采集系
postgres 跳表
08-16
在 PostgreSQL 数据库中，并没有内置的跳表（Skip List）索引实现。PostgreSQL 提供了多种索引类型，如B树索引、哈希索引、GiST索引和GIN索引等，但没有直接支持跳表的索引类型。 B树索引是 PostgreSQL 中最常用的索引类型之一。它适用于范围查询和等值查询，并且可以保持数据有序性。B树索引在处理数据块的平衡性和查询效率方面具有很好的性能。 除了B树索引之外，PostgreSQL 还提供了其他类型的索引用于特定的场景。例如，哈希索引适用于等值查询，可以提供快速的哈希查找；GiST 索引（通用搜索树）和 GIN 索引（通用倒排索引）适用于全文搜索和复杂的匹配查询。 虽然 PostgreSQL 不提供内置的跳表索引实现，但是你可以使用扩展或自定义索引实现跳表的功能。通过编写自定义插件或使用第三方扩展，你可以在 PostgreSQL 中实现跳表索引。这需要一定的开发工作，并且需要充分测试和评估性能。 需要注意的是，自定义实现的跳表索引可能会受到 PostgreSQL 内核版本更新的影响，并且可能无法享受到 PostgreSQL 内置索引的一些优化和支持。 总之，PostgreSQL 并没有内置的跳表索引实现，但提供了其他类型的索引，如B树索引、哈希索引、GiST索引和GIN索引等，用于满足不同的查询需求。如果需要使用跳表索引，你可以考虑自定义实现或使用第三方扩展。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值