跳表的实现插入删除搜索算法详解

Skip list -- 跳跃表的插入删除搜索等ADT操作的实现与测试 源代码如下: #include #include #define lgNmax 5 typedef char Key; struct Item{Key key;}; typedef struct STnode* link; struct STnode{ Item item ; link *next; //多个链接域组成的数组 int sz ; // 该节点的链接数 阅读详情

(本文地址:http://blog.youkuaiyun.com/freeelinux/article/details/53114687)

跳表久闻其名,以前写过AVL树,红黑树,都是平衡结构。但是跳表呢,它不是树形结构,它是通过链表实现的。

我们知道,在链表中查找一个元素的时间复杂度是O(n)。

在一个有序链表中,我们如果在链表中部额外增加一个结点,那么查找某个元素的次数将会是 n/2+1 次。类似于二分查找。

有了这个思想,那么现在就可以实行跳跃表了。

先看图,有个印象,再解释。



如图,每个结点都有一个指针数组域,指向它下一个结点。普通链表成为0级链,增加一级成为1级链。可见结点指针数组域最大的大小是级数level+1。

为什么需要指针数组呢?我们利用数组下标的特性,将同一级链表的所有元素都与同一下标关联起来,同一下标中的指针存放的是下一个同一级跳表元素的地址。

比如索引20,那么有两种方式,(我们称第一个结点为头结点head_,link_[]是指针数组,详细见下面定义):

1.head_->link[0]

2.head_->link[1]

那么head_->link_[3]呢,它直接索引到40去了。通过这种层次结构,我们可以很容易实现不同层级链表的遍历,后续代码也会给出。

另外指针数组精髓不止这一处,当我们要查找元素时,我们从跳表的当前最高级数开始查找,比如我们要查找30,我们首先先从i=2(下标从0开始)层查找,首先索引到40,

发现30<40,这是我们试一试下标减1降级。数组的好处就体现出来了,i现在值为1,查找link_[1],索引到24,到这里可能有一种熟悉的感觉,查找范围一下缩小了一半,难道这不是另一种形式的二分查找吗?

是的,查找元素,大于就降级,最终剩下一个元素,要么找到了,要么跳表中就没有。这种方法,使跳表的查找由普通链表的O(n)降到了O(lgn),这无疑是性能的飞跃。

一个有n个元素的跳表理性情况下链级数为log2n,即跳表的最高级数为log2n-1。

指针数组相当于虚拟出了额外的几层链表,实际上真实数据只有第0级,其他高于0级的索引都指向第0级真实元素。

对于跳表的设计还有一个特别之处,就是我们再使用last_[]来存放查找到某个元素的所有层级的前驱地址。这样在删除,加入某个元素时,就可以很方便的把每一层级的链表都更新,而不是某一层断掉。另外,有一点要注意,当我们更新跳表当前级数levels_时,要注意将新的last_[levels]指向tail_,不然我们后续增删都是通过levels_从最高增递减方式访问,会出现错误。

下面是skip_node类型的定义:

const int DEFAULT_SIZE = 100;

template <typename T>
struct skip_node {
    T            data_;
    skip_node<T> **link_;    //pointer array size default 100
    skip_node(int size = DEFAULT_SIZE){
        link_ = new(std::nothrow) skip_node<T>*[size];
        assert(link_ != NULL);
    }   
    ~skip_node(){
        delete []link_;
    }   


在上面的跳表结点中,我们采用用template机制来达到泛型的目的。data_元素可以是整型,字符型,甚至自定义的类型,自定义类型需要重载相关运算符。

下面是skip_list的定义:

template <typename T>
class skip_list {
public:
    skip_list(const T& large, int max_level);
    ~skip_list();
public:
    bool insert(const T& el);
    bool remove(const T& el);
    bool search(const T& el);
    void traverse() const;
protected:
    bool assert_is_valid(const T& el);
    int  pick_level();
    skip_node<T>* save_search(const T& k);
private:
    int          max_level_;
    int          levels_;
    T            tail_key_;
    skip_node<T> *head_;
    skip_node<T> *tail_;
    skip_node<T> **last_;
};


max_level_:最大级数值,由于级数过多会影响效率,我们需要控制级数的极值。

levels_:当前跳表最大级数值

tail_key_:该值是你定义的T类型的最大值,若T类型是结构体,那还需要传入定制好的该结构体的最大值。该值存放在tai_节点中。

head_:这是 链表的头结点,为了算法通用,不存放任何数据,只有指向各级节点的指针域有用。

tail_:跳表的尾节点,我们定义了一个极大值,通过该结点来辅助二分,该节点不存放任何数据。

last_:存放查找到节点的所有层级的前驱。在save_search中用到。

search()函数是公有供用户使用的函数,save_search()函数是内部插入删除访问的,因为插入删除牵扯到该结点每一层级的的改动,需要将该结点关联的每一层级前驱保存下来,以备更新。

代码实现如下:

#ifndef _SKIP_LIST_H
#define _SKIP_LIST_H

#include <iostream>
#include <assert.h>
#include <limits.h>

const int DEFAULT_SIZE = 100;

template <typename T>
struct skip_node {
	T            data_;
	skip_node<T> **link_;    //pointer array size default 100
	skip_node(int size = DEFAULT_SIZE){
		link_ = new(std::nothrow) skip_node<T>*[size];
		assert(link_ != NULL);
	}
	~skip_node(){
		delete []link_;
	}
};

template <typename T>
class skip_list {
public:
	skip_list(const T& large, int max_level);
	~skip_list();
public:
	bool insert(const T& el);
	bool remove(const T& el);
	bool search(const T& el);
	void traverse() const;
protected:
	bool assert_is_valid(const T& el);
	int  pick_level(); 
	skip_node<T>* save_search(const T& k);
private:
	int          max_level_;
	int          levels_;
	T            tail_key_;
	skip_node<T> *head_;
	skip_node<T> *tail_;
	skip_node<T> **last_;
};

template <typename T>
skip_list<T>::skip_list(const T& large, int max_level)
	: tail_key_(large), max_level_(max_level)
{
	head_ = new(std::nothrow) skip_node<T>(max_level_+1);
	assert(head_ != NULL);
	tail_ = new(std::nothrow) skip_node<T>(0);
	assert(tail_ != NULL);
	tail_->data_ = large;
	last_ = new(std::nothrow) skip_node<T>*[max_level_+1];
	assert(last_ != NULL);
		
	for(int i=0; i<=max_level_; ++i)
		head_->link_[i] = tail_;
	levels_ = 0;
}

template <typename T>
skip_list<T>::~skip_list()
{
		skip_node<T>* tmp = NULL;;
		while(tmp != tail_){
			tmp = head_->link_[0];
			delete head_;
			head_ = tmp;
		}
		delete tail_;
		delete []last_;
}

template <typename T>
bool skip_list<T>::search(const T& key)
{
	if(!assert_is_valid(key))
		return false;
	
	skip_node<T>* p = head_;
	for(int i=levels_; i>=0; --i){ //notice != tail_, for tail_ does not assigned  link_ space
		while(p->link_[i]->data_ < key)
			p = p->link_[i];
	}
	return p->link_[0]->data_ == key ? true : false;
}

template <typename T>
skip_node<T>* skip_list<T>::save_search(const T& key)
{
	if(!assert_is_valid(key))
		return NULL;
	
	skip_node<T>* p = head_;
	for(int i=levels_; i>=0; --i){
		while(p->link_[i]->data_ < key)    //operator <
			p = p->link_[i];
		last_[i] = p;        //last_[i] storge node ptrs which point the k in all levels
	}
	return p->link_[0];
}

template <typename T>
int skip_list<T>::pick_level()
{
	int cnt = 0;
	while(rand() < (RAND_MAX>>1))
		++cnt;
	return cnt > max_level_ ? max_level_ : cnt;
}

template <typename T>
bool skip_list<T>::assert_is_valid(const T& el)
{
	return (el >= (T)0 && el < tail_key_);    //if not POD, pls operation reload    
}


template <typename T>
bool skip_list<T>::insert(const T& el)
{
	skip_node<T>* p = save_search(el);
	if(p == NULL || p->data_ == el)
		return false;
	
	int lev = pick_level();
	if(lev > levels_){
		++levels_;
		last_[levels_] = head_;  //don't forget this line, if you add the levels, pls modify the last array
	}

	skip_node<T>* new_node = new(std::nothrow) skip_node<T>(levels_+1);
	assert(new_node != NULL);
	new_node->data_ = el;

	for(int i=levels_; i>=0; --i){
		new_node->link_[i] = last_[i]->link_[i];
		last_[i]->link_[i] = new_node;
	}
	return true;
}

template <typename T>
bool skip_list<T>::remove(const T& el)
{
	skip_node<T>* p = save_search(el);
	if(p == NULL || p == tail_)
		return false;
	
	for(int i=0; i<=levels_ && last_[i]->link_[i]->data_ == el; ++i){//if you remove the low levels elem, maybe the high levels does
		last_[i]->link_[i] = p->link_[i];                     //not contain it, so ensure last_[i]->data_ == el;
	}
	while(levels_ > 0 && head_->link_[levels_] == tail_)
		--levels_;
	return true;
}

using namespace std;

template <typename T>
void skip_list<T>::traverse() const
{
	skip_node<T> *p = NULL;
	for(int i=levels_; i>=0; --i){
		std::cout<<"head->";
		p = head_->link_[i];
		while(p->data_ < tail_key_){
			std::cout<<p->data_<<"->";
			p = p->link_[i];
		}
		std::cout<<"tail";
		std::cout<<std::endl;
	}
}

#endif


测试用例:

#include "skip_list.h"

#include <iostream>
#include <limits.h>
using namespace std;

struct key_value {
	int key_;
	int value_;
	key_value() {}      //must have this line, the data_ in skip_node when not assigned value will call default constructor.
	key_value(int key, int value = 0)
		: key_(key), value_(value)
	{}
	~key_value() {}
	bool operator<(const key_value& other) const{
		return key_ < other.key_;
	}
	bool operator>=(const key_value& other) const{
		return key_ >= other.key_;
	}
	key_value& operator=(const key_value& other){
		if((void *)this != (void *)&other){
			key_ = other.key_;
			value_ = other.value_;
		}
		return *this;
	}
	bool operator==(const key_value& other) const{
		return key_ == other.key_;
	}
	friend ostream& operator<<(ostream& out, const key_value& obj);
};

ostream& operator<<(ostream& out, const key_value& obj)
{
	out<<'('<<obj.key_<<','<<obj.value_<<')';
	return out;
}

#if 1
int main()
{
	key_value v1(1, 1);
	key_value v2(2, 1);
	key_value v3(2, 1);
	key_value v4(3, 1);
	key_value v5(4, 1);
	key_value v6(9, 1);
	key_value large(INT_MAX, 0);
	skip_list<key_value> sl(large, 7);

	sl.insert(v1);
	sl.insert(v2);
	sl.insert(v3);
	sl.insert(v4);
	sl.insert(v5);
	sl.insert(v6);

	sl.traverse();

	sl.remove(v6);
	sl.remove(v1);
	sl.remove(v3);
	sl.remove(v4);
	sl.remove(v5);
	sl.remove(v2);

	sl.traverse();

	return 0;
}
#endif

#if 0
int main()
{
	skip_list<int> sl(INT_MAX, 7);

	sl.insert(1);
	sl.insert(2);
	sl.insert(3);
	sl.insert(2);
	sl.insert(9);
	sl.insert(4);
	sl.insert(5);
	sl.insert(10);
	sl.insert(300);
	
	sl.traverse();

	cout<<sl.search(1)<<endl;	
	cout<<sl.search(2)<<endl;	
	cout<<sl.search(3)<<endl;	
	cout<<sl.search(4)<<endl;	
	cout<<sl.search(5)<<endl;	
	cout<<sl.search(9)<<endl;	
	cout<<sl.search(10)<<endl;	
	cout<<sl.search(300)<<endl;	
	cout<<sl.search(250)<<endl;	
	cout<<sl.search(-1)<<endl;	

/*
	sl.traverse();
	sl.remove(2);
	sl.traverse();
	sl.remove(300);
	sl.traverse();
	sl.remove(1);
	sl.traverse();
	sl.remove(4);
	sl.traverse();
	sl.remove(9);
	sl.remove(3);
	sl.remove(5);
	sl.remove(300);
	sl.remove(10);
	sl.traverse();
*/
	return 0;
}
#endif


自定义类型需要重载相关运算符。上述代码全部通过测试,并利用valgrind检测无内存泄漏。

HBase内存结构之跳表数据结构浅析 最近学习HBase源码时发现HRegion在sotre管理上用到了跳表数据结构ConcurrentSkipListMap: ConcurrentSkipListMap有几个ConcurrentHashMap 不能比拟优点: 1、ConcurrentSkipListMap 的key是有序的。 2、ConcurrentSkipListMap 支持更高的并发。 阅读详情

相关推荐

数据结构基础:跳表全面解析

跳表(Skip List)是一种随机化的数据结构,基于并联的有序链表,其效率可比拟于二叉搜索树(如红黑树、AVL树等)。跳表的平均查找和插入时间复杂度都是O(log n),但与平衡树相比,跳表的实现更为简单,且常数因子更小。跳表是对有序链表的一种扩展,通过维护一系列分层的链表,并在每一层中跳过部分元素,从而加快查找速度。跳表上层的链表作为下层链表的"快速通道",使得在查找时可以先在高层链表中进行大步跳跃,再在底层链表中进行精确定位。

脱发是不可能的博客 941

20200321跳表

对于一个单链表来讲,即便链表中存储的数据是有序的,如果我们要想在其中查找某个数据,也只能从头到尾遍历链表。这样查找效率就会很低,时间复杂度会很高,是 O(n). 对链表建立一级“索引”,查找起来是不是就会更快一些呢?每两个结点提取一个结点到上一级,我们把抽出来的那一级叫作索引或索引层。你可以看我画的图。图中的 down 表示 down 指针,指向下一级结点。 ...

只留清气满乾坤 214

面试必备:跳表(Skip List)的核心原理与实现

在面试过程中,数据结构是考察的重点之一。跳表作为一种特殊的数据结构,因其在搜索、插入和删除操作上有着不错的性能,成为了很多面试官喜欢考察的内容。本文的目的就是全面且详细地讲解跳表的核心原理和实现方式,让读者能够深入理解跳表,为面试和实际开发做好准备。我们将涵盖跳表的基本概念、原理、代码实现、应用场景等多个方面。本文将按照以下结构展开:首先介绍跳表的核心概念,通过故事引入并以通俗易懂的方式解释相关概念及它们之间的关系,给出核心概念原理和架构的文本示意图以及Mermaid流程图。

AI 算法实战派 1020

跳表的实现与分析

问题描述 实现并分析跳表结构 构造并实现跳表ADT,跳表ADT包括如下操作: 初始化跳表 查找跳表内是否存在元素x 向跳表插入元素x 删除跳表内元素x,若不存在则抛出异常 删除跳表内关键字最小的元素 删除跳表内关键字最大的元素 其他根据需要实现,注意数据的可访问性 Input 第一行包含两个数字 n, m (0≤n≤1000,0≤m≤10000≤n≤1000,0≤m≤1000) 之后的 n 行...

龙征天的博客 1672

ISP Tuning实战指南:从基础到高级的色彩与亮度优化

本文详细介绍了ISP Tuning的基础概念与高级调优技术,包括黑电平校正(BLC)、自动白平衡(AWB)、色彩校正矩阵(CCM)和Gamma曲线调整等核心算法。通过实战案例和调试技巧,帮助工程师提升摄像头成像质量,解决高光过曝、暗部噪点等常见问题,适用于智能门铃、车载摄像头等多种场景。

weixin_30879169的博客 112

稀疏阵列选型指南:互质阵、嵌套阵、MRA,谁才是你项目里的‘性价比之王’?

本文深入探讨了稀疏阵列技术中的互质阵、嵌套阵和MRA三大架构的工程化选型策略,重点分析了它们在DOA估计、自由度、旁瓣抑制和计算复杂度等核心指标上的表现。通过实际案例和配置示例,为智能天线、声学定位和毫米波雷达等应用场景提供技术选型指南,帮助研发团队在硬件成本与性能之间找到最佳平衡点。

weixin_42525005的博客 489

跳跃表(skiplist )详解及其C++编程实现

跳表SkipList跳表SkipList1、背景2、定义2.1、SkipList基本数据结构及其实现3、实现4、使用方法4.1、跳表的创建4.2、跳表插入操作参考 跳表SkipList 1、背景 为什么选择跳表? 目前经常使用的平衡数据结构有:B树,红黑树,AVL树,Splay Tree, Treep等。跳表是平衡树的一种替代的数据结构,但是和红黑树不相同的是,跳表对于树的平衡的实现是基于一种随机化的算法的,这样也就是说跳表的插入和删除的工作是比较简单的。 用跳表吧,跳表是一种随机化的数据结构,目前开源软件

JMW1407的博客 4048

UNet 改进(45):轻松集成Triplet Attention,让分割效果起飞!

本文介绍了一种在U-Net架构中集成CSRA残差注意力模块的方法。该模块通过结合通道注意力和空间注意力机制,在U-Net的瓶颈层对特征进行自适应重标定,使网络聚焦于关键区域。文章详细解析了代码实现,包括基础构建块DoubleConv、核心CSRA模块原理及其在U-Net中的战略位置集成。测试表明该模型能保持标准U-Net的输入输出维度,同时通过注意力机制提升特征选择能力。这种模块化设计便于在不同任务中应用,为图像分割领域提供了有效的注意力增强方案。

2401_82355416的博客 105

跳表(Skip List)的介绍以及查找插入删除等操作

今天有同学去面试,被问到了“跳表”这种数据结构,说实话我之前对它了解不多,于是上网查了跳表的资料,并在这里总结一下。 什么是跳表?要说清楚这个问题,我们就要先从普通的有序链表说起。一个普通有序列表的结构如下: 我们可以看到,上图所示的链表按照由小到大的顺序排列(-1表示最小值,1表示最大值,这是本文的一个约定),如果我们想要查找一个元素x,算法如下: 1 2

wusecaiyun的专栏 873

RT-DETR改进策略【模型轻量化】| 替换骨干网络为 GhostNet V3 2024华为的重参数轻量化模型

本文记录的是基于 GhostNetV3 的 RT-DETR轻量化改进方法研究。GhostNetV3的轻量模块采用方法,训练时为深度可分离卷积和1×1卷积添加,推理时通过移除分支、折叠操作,能够在不增加推理成本的同时提高性能,从而实现RT-DETR的轻量化改进。

Limiiiing的博客 973

浏览器缓存导致代码不更新?一招解决部署后用户仍看到旧页面的问题

方案效果适用场景文件名哈希永久解决前端工程化项目HTTP缓存头控制精准控制需服务器权限Meta标签部分生效临时补救方案最佳实践:入口HTML禁用缓存,静态资源使用哈希文件名 + 长期缓存,达到「秒级更新」+「高性能」的平衡!

江拥羡橙的博客 813

跳表在Java中的实现

跳表是一种数据结构,用于借助连接到元素子序列的链表层次结构来存储元素的排序列表。跳表允许以有效的方式处理项目查找。跳表是一种概率数据结构,这意味着它跳过整个列表中的几个元素,因此称为跳表。我们可以将跳表作为链表的扩展版本。与链表允许插入、删除和搜索元素的方式类似,跳表也允许搜索元素、从列表中删除元素和插入元素。它将包含一个基本列表,其中包含一组元素,这些元素将维护后续元素的链接层次结构。跳表没有特定的语法,但它有一个算法。在研究算法之前,我们需要检查基本跳表操作的类型。让我们看看跳表是如何以算法的方式工作的

javaYY_的博客 1563

Windows 下 Claude Code Desktop 安装与使用全记录:从零到一的保姆级图文教程

本文主要介绍了Windows 下 Claude Code 安装全记录:从零到一的保姆级图文教程,希望能对学习使用 Claude Code 的同学们有所帮助。 文章目录 1. 背景 2. 安装Claude Code Desktop 3. 配置第三方API 4. 日常使用

weixin_43178406的博客 8万+

跳表的介绍与实现

作用/目的 跳表作为一种数据结构通常用于取代平衡树。 起因 平衡树可以用于表示抽象的数据类型如字典和有序链表,它通过树旋转(Tree Rotation)操作强制使树结构保持平衡 来保证节点搜索的效率。在数据为随机插入的情况下,平衡树性能表现良好;但数据为顺序插入或者需要删除节点的 情况下,平衡树的性能就会有些糟糕。 跳表可以作为平衡树的一种替代选择。它使用随机的平衡策略

cll的专栏 7703

在 Zynq 7010 上运行 VxWorks 7.0 的详细流程【持续更新】

本文介绍了在Zynq 7010开发板上运行VxWorks 7.0的完整流程。主要包括:1)使用Vivado创建硬件设计,配置Zynq模块并生成比特流文件;2)通过Workbench 4创建VxWorks工程,配置启动参数并生成镜像;3)下载运行步骤。此外还讲解了使用Workbench 4开发VSB和VIP工程的方法,包括工程创建、配置和调试流程。文中提供了关键操作截图和注意事项,为开发者提供了完整的Zynq 7010平台VxWorks开发解决方案。

weixin_45397344的博客 1224

“华为杯”研究生数学建模竞赛2020年-【华为杯】B题:汽油辛烷值优化建模(附优秀论文)

摘 要:本文通过机器学习算法和数据挖掘技术,建立了汽油辛烷值(RON)损失的预测模型,在保证汽油产品脱硫效果的前提下,以降低汽油辛烷值损失在30%以上为目标,给出每个样本的优化操作条件。针对第一问,对285号和313号原始数据用给定的数据处理规范进行预处理,对每一列变量求期望,得到最终的数据补充到相应的样本编号。针对第二问,首先对数据样本按照最大最小限幅以及拉依达法则进行列变量清洗,通过两轮特征筛选确定变量:结合处理后的数据,针对产品中硫含量、RON损失值用。

getusushu的博客 1251

什么是跳表?Redis为什么使用跳表来实现有序集合?

为什么选择跳表 目前经常使用的平衡数据结构有:B树,红黑树,AVL树,Splay Tree, Treep等。 想象一下,给你一张草稿纸,一只笔,一个编辑器,你能立即实现一颗红黑树,或者AVL树 出来吗? 很难吧,这需要时间,要考虑很多细节,要参考一堆算法与数据结构之类的树, 还要参考网上的代码,相当麻烦。 用跳表吧,跳表是一种随机化的数据结构,目前开源软件 Redis 和 L...

ChaunceyChen的博客 4190

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

数据结构之跳表SkipList、ConcurrentSkipListMap

概述SkipList,跳表,跳跃表,在LevelDB和Lucene中都广为使用。跳表被广泛地运用到各种缓存实现当中,跳跃表使用概率均衡技术而不是使用强制性均衡,因此对于插入和删除结点比传统上的平衡树算法更为简洁高效。Skip lists are data structures that use probabilistic ...

cnzzs的博客 1247

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

SkipList 跳表

为什么选择跳表 目前经常使用的平衡数据结构有:B树,红黑树,AVL树,Splay Tree, Treep等。   想象一下,给你一张草稿纸,一只笔,一个编辑器,你能立即实现一颗红黑树,或者AVL树 出来吗? 很难吧,这需要时间,要考虑很多细节,要参考一堆算法与数据结构之类的树, 还要参考网上的代码,相当麻烦。   用跳表吧,跳表是一种随机化的数据结构,目前

likun_tech的专栏 3629

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

Redis zset的数据结构:SkipList(跳表)的原理及实现

1.数据结构 1.1 简介 跳表(skiplist)是一个查询/插入/删除 复杂度o(lgn)的数据结构。在查询上跟平衡树的复杂度一致,因此是替代平衡树的方案。在redis的zset,leveldb都有应用。发现这个算法也解决了我一个问题。各种平衡树在工业界是广泛应用,帮助我们快速查找,插入数据,但其思想的复杂也让大家不是那么容易接触。当时想直接对有序链表进行二分搜索,那岂不是很容易做到相同复杂度...

山月记 5937

Skpi List跳表

为什么选择跳表 目前经常使用的平衡数据结构有:B树,红黑树,AVL树,Splay Tree, Treep等。   想象一下,给你一张草稿纸,一只笔,一个编辑器,你能立即实现一颗红黑树,或者AVL树 出来吗? 很难吧,这需要时间,要考虑很多细节,要参考一堆算法与数据结构之类的树, 还要参考网上的代码,相当麻烦。   用跳表吧,跳表是一种随机化的数据结构,目前

VergiL Wang的专栏 5166

二叉树 跳表_java 实现跳表(skiplist)及论文解读

什么是跳跃表跳表由William Pugh发明。他在论文 《Skip lists: a probabilistic alternative to balanced trees》中详细介绍了跳表的数据结构和插入删除等操作。跳表是一种可以用来代替平衡树的数据结构,跳表使用概率平衡而不是严格执行的平衡,因此,与等效树的等效算法相比,跳表中插入和删除的算法要简单得多,并且速度要快得多。Skip_list....

weixin_29306261的博客 125

跳表的实现原理

我们知道二叉搜索算法能够高效的查询数据,但是需要一块连续的内存,而且增删改效率很低。 跳表,是基于链表实现的一种类似“二分”的算法。它可以快速的实现增,删,改,查操作。 我们先来看一下单向链表如何实现查找 当我们要在该单链表中查找某个数据的时候需要的时间复杂度为O(n). 怎么提高查询效率呢?如果我们给该单链表加一级索引,将会改善查询效率。 如图所示,当我们每隔一个节点就提取出来一个元素到上一层,把这一层称作索引,其中的down指针指向原始链表。 当我们查找元素16的时候,单链表需要..

360linker 1507

跳表有哪些算法?

从最高层索引开始,在当前层向右查找,遇到大于目标值的节点就下降一层,逐步逼近目标位置。使用概率控制节点层数,保证上层节点数量约为下层的一半,维持跳表的平衡性。先查找到插入位置,随机生成新节点的层数,然后在各层插入节点并更新指针。先查找到要删除的节点及其在各层的前驱节点,然后逐层更新指针连接,最后释放节点。(3)创建新节点,如果新节点层数超过当前最大层,更新跳表的最大层数。如果下一个节点值 = 目标值:查找成功,返回节点。本节点到下一层同节点之间的节点数量(跨度)。将前驱节点的指针指向目标节点的后继节点。

kupePoem的专栏 889

二叉树 跳表_跳表(skiplist)论文解读及 java 实现

什么是跳跃表跳表由William Pugh发明。他在论文 《Skip lists: a probabilistic alternative to balanced trees》中详细介绍了跳表的数据结构和插入删除等操作。跳表是一种可以用来代替平衡树的数据结构,跳表使用概率平衡而不是严格执行的平衡,因此,与等效树的等效算法相比,跳表中插入和删除的算法要简单得多,并且速度要快得多。Skip_...

weixin_39980917的博客 178
上一篇: 8. String to Integer (atoi)
下一篇: 453. Minimum Moves to Equal Array Elements
FreeeLinux
博客等级 码龄11年 421粉丝 356原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值