手写一个简易跳表（Java版）

最新推荐文章于 2024-05-10 20:24:59 发布
最新推荐文章于 2024-05-10 20:24:59 发布
阅读量984 收藏 5
点赞数 1
分类专栏： 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TJtulong/article/details/106138945
版权

跳表概述

跳表是由William Pugh于1990年发明，他在论文中给出了跳表的描述：

Skip lists are a data structure that can be used in place of balanced trees. Skip lists use probabilistic balancing rather than strictly enforced balancing and as a result the algorithms for insertion and deletion in skip lists are much simpler and significantly faster than equivalent algorithms for balanced trees.

跳表是平衡树的一种替代的数据结构，但是和红黑树不相同的是，跳表对于树的平衡的实现是基于一种随机化的算法的，这样也就是说跳表的插入和删除的工作是比较简单的。

与单向链表不同，每一个结点不单单只包含指向下一个结点的指针，可能包含很多个指向后续结点的指针，这样就可以跳过一些不必要的结点，从而加快查找、删除等操作。对于一个链表内每一个结点包含多少个指向后续元素的指针，后续节点个数是通过一个随机函数生成器得到，这样子就构成了一个跳跃表。

随机生成的跳跃表如下图所示：

这基本上就是跳表的核心思想，其实也是一种通过空间来换取时间的一个算法，通过在每个节点中增加了向前的指针，从而提升查找的效率。目前开源软件 Redis 和 LevelDB 都有用到它。

其增删改查的时间复杂度为O(log n).

跳表的Java简易实现

节点

如果一个节点存在k个向前的指针的话，那么称该节点是k层的节点。

一个跳表的MaxLevel为跳表中所有节点中最大的层数。

public static class SkipListNode {
	public Integer value;
	public ArrayList<SkipListNode> nextNodes;

	public SkipListNode(Integer value) {
		this.value = value;
		nextNodes = new ArrayList<SkipListNode>();
	}
}

跳表数据类型

public static class SkipList {
	private SkipListNode head;
	private int maxLevel;
	private int size;
	private static final double PROBABILITY = 0.5;
}

PROBABILITY表示生成下一层的概率

初始化

public static class SkipList {
	private SkipListNode head;
	private int maxLevel;
	private int size;
	private static final double PROBABILITY = 0.5;
	
    public SkipList() {
		size = 0;
		maxLevel = 0;
		head = new SkipListNode(null);
		head.nextNodes.add(null);
	}
    
	public SkipListNode getHead() {
		return head;
	}
}

查找操作

以查找19为例，先找到6，再找到25，19比25小，在6和25之间；再找到9，再找到17，再找到25,19比25小，在17和25节点之间，17再下一个即为19。

public static class SkipList {
	private SkipListNode head;
	private int maxLevel;
	private int size;
	private static final double PROBABILITY = 0.5;
    
    // Returns the skiplist node with greatest value <= e
	private SkipListNode find(Integer e) {
		return find(e, head, maxLevel);
	}

	// Returns the skiplist node with greatest value <= e
	// Starts at node start and level
	private SkipListNode find(Integer e, SkipListNode current, int level) {
		do {
			current = findNext(e, current, level);
		} while (level-- > 0);
		return current;
	}

	// Returns the node at a given level with highest value less than e
    // 关键方法：找到给定level中value小于e的最大节点
	private SkipListNode findNext(Integer e, SkipListNode current, int level) {
		SkipListNode next = current.nextNodes.get(level);
		while (next != null) {
			Integer value = next.value;
			if (lessThan(e, value)) { // e < value
				break;
			}
			current = next;
			next = current.nextNodes.get(level);
		}
		return current;
	}
    
    private boolean lessThan(Integer a, Integer b) {
		return a.compareTo(b) < 0;
	}

	private boolean equalTo(Integer a, Integer b) {
		return a.compareTo(b) == 0;
	}
}

插入操作

由于跳表数据结构整体上是有序的，所以在插入时，需要首先查找到合适的位置，然后就是修改指针（和链表中操作类似），然后更新跳表的level变量。

public static class SkipList {
	private SkipListNode head;
	private int maxLevel;
	private int size;
	private static final double PROBABILITY = 0.5;
    
    public void add(Integer newValue) {
		if (!contains(newValue)) {
			size++;
			int level = 0;
			while (Math.random() < PROBABILITY) {
				level++;
			}
			while (level > maxLevel) {
				head.nextNodes.add(null);
				maxLevel++;
			}
			SkipListNode newNode = new SkipListNode(newValue);
			SkipListNode current = head;
			do {
				current = findNext(newValue, current, level);
				newNode.nextNodes.add(0, current.nextNodes.get(level));
				current.nextNodes.set(level, newNode);
			} while (level-- > 0);
		}
	}
    
    public boolean contains(Integer value) {
		SkipListNode node = find(value);
		return node != null && node.value != null && equalTo(node.value, value);
	}
}

删除操作

删除操作类似于插入操作，包含如下3步：查找到需要删除的结点、删除结点、调整指针。

public static class SkipList {
	private SkipListNode head;
	private int maxLevel;
	private int size;
	private static final double PROBABILITY = 0.5;
    
    public void delete(Integer deleteValue) {
		if (contains(deleteValue)) {
			SkipListNode deleteNode = find(deleteValue);
			size--;
			int level = maxLevel;
			SkipListNode current = head;
			do {
				current = findNext(deleteNode.value, current, level);
				if (deleteNode.nextNodes.size() > level) {
					current.nextNodes.set(level, deleteNode.nextNodes.get(level));
				}
			} while (level-- > 0);
		}
	}
}

遍历

遍历第0层的节点即可。

public static class SkipList {
	private SkipListNode head;
	private int maxLevel;
	private int size;
	private static final double PROBABILITY = 0.5;
    
    // Inner Class
    public static class SkipListIterator implements Iterator<Integer> {
		SkipList list;
		SkipListNode current;

		public SkipListIterator(SkipList list) {
			this.list = list;
			this.current = list.getHead();
		}

		public boolean hasNext() {
			return current.nextNodes.get(0) != null;
		}

		public Integer next() {
			current = current.nextNodes.get(0);
			return current.value;
		}
	}
    
    public Iterator<Integer> iterator() {
		return new SkipListIterator(this);
	}
}

全部代码

import java.util.ArrayList;
import java.util.Iterator;

public class SkipList_Simple {

	public static class SkipListNode {
		public Integer value;
		public ArrayList<SkipListNode> nextNodes;

		public SkipListNode(Integer value) {
			this.value = value;
			nextNodes = new ArrayList<SkipListNode>();
		}
	}

	public static class SkipListIterator implements Iterator<Integer> {
		SkipList list;
		SkipListNode current;

		public SkipListIterator(SkipList list) {
			this.list = list;
			this.current = list.getHead();
		}

		public boolean hasNext() {
			return current.nextNodes.get(0) != null;
		}

		public Integer next() {
			current = current.nextNodes.get(0);
			return current.value;
		}
	}

	public static class SkipList {
		private SkipListNode head;
		private int maxLevel;
		private int size;
		private static final double PROBABILITY = 0.5;

		public SkipList() {
			size = 0;
			maxLevel = 0;
			head = new SkipListNode(null);
			head.nextNodes.add(null);
		}

		public SkipListNode getHead() {
			return head;
		}

		public void add(Integer newValue) {
			if (!contains(newValue)) {
				size++;
				int level = 0;
				while (Math.random() < PROBABILITY) {
					level++;
				}
				while (level > maxLevel) {
					head.nextNodes.add(null);
					maxLevel++;
				}
				SkipListNode newNode = new SkipListNode(newValue);
				SkipListNode current = head;
				do {
					current = findNext(newValue, current, level);
					newNode.nextNodes.add(0, current.nextNodes.get(level));
					current.nextNodes.set(level, newNode);
				} while (level-- > 0);
			}
		}

		public void delete(Integer deleteValue) {
			if (contains(deleteValue)) {
				SkipListNode deleteNode = find(deleteValue);
				size--;
				int level = maxLevel;
				SkipListNode current = head;
				do {
					current = findNext(deleteNode.value, current, level);
					if (deleteNode.nextNodes.size() > level) {
						current.nextNodes.set(level, deleteNode.nextNodes.get(level));
					}
				} while (level-- > 0);
			}
		}

		// Returns the skiplist node with greatest value <= e
		private SkipListNode find(Integer e) {
			return find(e, head, maxLevel);
		}

		// Returns the skiplist node with greatest value <= e
		// Starts at node start and level
		private SkipListNode find(Integer e, SkipListNode current, int level) {
			do {
				current = findNext(e, current, level);
			} while (level-- > 0);
			return current;
		}

		// Returns the node at a given level with highest value less than e
		private SkipListNode findNext(Integer e, SkipListNode current, int level) {
			SkipListNode next = current.nextNodes.get(level);
			while (next != null) {
				Integer value = next.value;
				if (lessThan(e, value)) { // e < value
					break;
				}
				current = next;
				next = current.nextNodes.get(level);
			}
			return current;
		}

		public int size() {
			return size;
		}

		public boolean contains(Integer value) {
			SkipListNode node = find(value);
			return node != null && node.value != null && equalTo(node.value, value);
		}

		public Iterator<Integer> iterator() {
			return new SkipListIterator(this);
		}

		/******************************************************************************
		 * Utility Functions *
		 ******************************************************************************/

		private boolean lessThan(Integer a, Integer b) {
			return a.compareTo(b) < 0;
		}

		private boolean equalTo(Integer a, Integer b) {
			return a.compareTo(b) == 0;
		}
	}

	public static void main(String[] args) {

	}
}

ConcurrentSkipListMap

ConcurrentSkipListMap是JDK1.6以后提供的一个并发的SkipList。

从上面的构造我们可以看到，Index节点包含了Node节点，除此之外，Index还有两个指针，一个指向同一个layer的下一个节点right，一个指向下一层layer的节点down。采用自旋+CAS的方式进行增删改查。

TJtulong
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
太刺激了，面试官让我手写跳表，而我用两种实现方式吊打了TA
java_xiaoo的博客
09-17 883
前言 本文，我将通过两种方式手写跳表，并结合画图，彻底搞定跳表实现的细节。 第一种方式为跳表的通用实现，第二种方式为彤哥自己发明的实现，并运用到HashMap的改写中。 好了，开始今天的学习吧，Let’s Go！ 文末有跳表和红黑树实现的HashMap的对比，不想看代码的同学也可以直达底部。 通用实现 通用实现主要参考JDK中的ConcurrentSkipListMap，在其基础上，简化，并优化一些东西，学好通用实现也有助于理解JDK中的ConcurrentSkipListMa...
手写跳表数据结构
qq_39144436的博客
06-04 450
跳表 是在 O(log(n)) 时间内完成增加、删除、搜索操作的数据结构。跳表相比于树堆与红黑树，其功能与性能相当，并且跳表的代码长度相较下更短，其设计思想与链表相似。
Java最全太刺激了，面试官让我手写跳表，而我用两种实现方式吊打了TA(1)，电商秒杀java面试题
2401_84691810的博客
05-10 712
让我们模拟一下查找的过程，比如，要查询8这个元素，只需要从头节点的最高层，往右到6这个节点，6在2层向右为空了，所以转到1层，向右到7这个节点，7再向右看一下，是9，比8大，所以7向下到0层，再向右，找到8，所以，整个走过的路径为：h(2)->6(2)->6(1)->7(1)->7(0)->8(0)。为了尝试解决这些问题，彤哥又自己研究了一种实现，这种实现不再区分头索引节点、索引节点、普通节点，把它们全部合并成一个，大家都是一样的，并且，我将它运用到了HashMap的改造中，来看看吧。
手写 跳跃表 java,SkipList跳跃表（Java实现）
weixin_26720271的博客
03-11 151
取自网络https://github.com/spratt/SkipListAbstractSortedSet.javapackage skiplist_m;/******************************************************************************* AbstractSortedSet ...
跳表(java代码实现)
qq_51955445的博客
02-02 900
练手写了一下跳表 一开始自己只看了思路，写了一晚上还是有两个小bug 所以第二次写参考了一下别的博客 跳表的java实现 算是写出了个能用的吧(应该) import java.util.*; /** * @author 20级三班刘宇阳 * @create 2022/2/2 */ /** * 跳表类 * @param <T> 泛型 */ public class SkipList<T>{ /** * 跳表结点 */ private
手写 Redis 数据结构，用 Java 代码以及 C 代码编写跳跃表实现
GitChat
10-21 251
跳跃表是一种有序的数据结构，从执行效率上甚至可以与平衡树相媲美，并且其实现比平衡树更加的简单，所以很多程序会优先使用跳跃表来替代平衡树。本节 Chat 将带领大家从时间复杂度分析、数据结构定义、接口设计、编码实现，来分析跳跃表是如何通过以空间换时间的方式提高执行效率，并且将其编写。为了配合同学的学习方向，笔者会从 Java 以及 C 语言两套代码进行编写讲解，同学可以自行选择阅读。 本节 Chat...
跳表（SkipList）_手写代码实现_java
weixin_42799120的博客
12-06 445
跳表java代码实现
跳表 java实现
01-29
跳表是由多个层构成的链表，每一层都是下一层链表的一个子集，最底层是原始的有序链表，而上层链表中的元素则是下层链表中某些元素的快照。这种设计使得在平均情况下，查找、插入和删除的时间复杂度都接近O(log n)。...
java跳表实现
11-06
首先，我们定义一个跳表节点（SkipListNode），它通常包含两个部分：值（value）和指向下一个节点的指针数组。这个指针数组的大小就是跳表的高度，数组中的每个元素都是一个链表节点的引用。跳表的高度不是固定的，...
structure 跳表 vs 红黑树.zip
最新发布
05-12
跳表（Skip List）是一种基于并行链表的数据结构，类似于平衡树，用于在有序的序列中快速查找一个元素。它通过在链表上方增加多级索引，以实现快速查找的目的。每个索引级别都是原始链表的一部分，但它们的节点选择...
线段跳表——跳表的一个拓展.pdf
01-12
线段跳表——跳表的一个拓展.pdf
跳表（skiplist）Java实现
11-27
简单得实现跳表相关功能 SkipList<Integer> skipList = new SkipList<Integer>(maxLevel); 提供insert和seach接口 删除接口可做类似操作
Java实现跳跃表(skiplist)的简单实例
08-29
主要介绍了Java编程中跳跃表的概念和实现原理，并简要叙述了它的结构，具有一定参考价值，需要的朋友可以了解下。
线段跳表——跳表的一个拓展.ppt
09-17
线段跳表——跳表的一个拓展.ppt
用java写一个跳表
weixin_35756624的博客
02-10 63
很高兴能回答你的问题。跳表是一种有序的数据结构，可以提供比普通数组更高的查询效率。要使用Java编写跳表，首先需要定义一个节点类，包括关键字和指向其他节点的指针。然后，需要定义一个跳表类，用于管理节点，提供查找、插入和删除操作。最后，需要实现一个排序算法，用于将跳表中的节点按照关键字的大小进行排序。 ...
跳表的简单原理及Java实现
liinux-Talk is cheap,show me the code.
01-01 646
跳表 跳表是一种简单，高效的快速查找结构，实现起来成本最小，并且速度也很快，只需要一个图就可以完美的解释跳跃表的样子，而且对于编程人员来说，要实现一个跳跃表看着图就能实现，以下就是跳跃表的结构图，没有什么难度。 跳跃表有几个特点，这种特点对于某些类型的查询是有相当的效率提升的。 它是有序的，跳跃表的特点就是有序的，所以对于一些有序类型的数据，比如整数，日期这种，用跳跃表可以进行...
跳表的java实现
qq_30761967的博客
04-14 267
首先贴出参考的博客： https://blog.csdn.net/moakun/article/details/79997037 根据这篇博客的代码自己实现了一个，添加了删除模块。 如果有理论不懂的可以看上面的博客也可以看下面的视频： https://www.bilibili.com/video/BV1z7411f7mE?from=search&seid=17814720194061...
手搓跳表——SkipList
真一居士的博客
08-25 246
public class SkipList { /** * 节点晋升索引的概率 */ private static final double PROMOTE_RATE = 0.5; /** * 描述跳表中头节点，哨兵 */ private Node head; /** * 描述跳表中尾节点，哨兵 */ private Node tail; /** * 当前索引层的高度 *.
手写创建表sql
一如既叼的博客
09-19 526
-- Create table create table ZC_YEARS_PIWEN ( id VARCHAR2(32) not null, years VARCHAR2(4), dwsh VARCHAR2(750), word_path VARCHAR2(1500), piwenImg_...
用Java写一个跳表
06-01
跳表（Skip List）是一种随机化的数据结构，它基于并联的链表，用于维护一个有序的元素序列。跳表支持快速的插入、删除和查找操作，时间复杂度为 O(log n)，与平衡树相当，但实现起来比平衡树简单。 下面是用 Java 实现的跳表代码： ```java import java.util.Random; public class SkipList { private static final int MAX_LEVEL = 16; // 跳表的最大层数 private int levelCount = 1; // 跳表的当前层数 private Node head = new Node(); // 跳表的头结点 private Random r = new Random(); // 随机数生成器 // 查找操作 public Node find(int value) { Node p = head; // 从跳表的顶层开始查找 for (int i = levelCount - 1; i >= 0; i--) { while (p.forwards[i] != null && p.forwards[i].data < value) { p = p.forwards[i]; } } // 如果找到了目标值，则返回该节点，否则返回 null if (p.forwards[0] != null && p.forwards[0].data == value) { return p.forwards[0]; } else { return null; } } // 插入操作 public void insert(int value) { int level = randomLevel(); Node newNode = new Node(); newNode.data = value; newNode.maxLevel = level; Node[] update = new Node[level]; for (int i = 0; i < level; i++) { update[i] = head; } Node p = head; for (int i = level - 1; i >= 0; i--) { while (p.forwards[i] != null && p.forwards[i].data < value) { p = p.forwards[i]; } update[i] = p; } for (int i = 0; i < level; i++) { newNode.forwards[i] = update[i].forwards[i]; update[i].forwards[i] = newNode; } if (levelCount < level) { levelCount = level; } } // 删除操作 public void delete(int value) { Node[] update = new Node[levelCount]; Node p = head; for (int i = levelCount - 1; i >= 0; i--) { while (p.forwards[i] != null && p.forwards[i].data < value) { p = p.forwards[i]; } update[i] = p; } if (p.forwards[0] != null && p.forwards[0].data == value) { for (int i = levelCount - 1; i >= 0; i--) { if (update[i].forwards[i] != null && update[i].forwards[i].data == value) { update[i].forwards[i] = update[i].forwards[i].forwards[i]; } } } } // 随机生成层数 private int randomLevel() { int level = 1; while (r.nextDouble() < 0.5 && level < MAX_LEVEL) { level++; } return level; } // 内部节点类 class Node { private int data = -1; private Node[] forwards = new Node[MAX_LEVEL]; private int maxLevel = 0; @Override public String toString() { StringBuilder builder = new StringBuilder(); builder.append("{ data: "); builder.append(data); builder.append("; levels: "); builder.append(maxLevel); builder.append(" }"); return builder.toString(); } } // 打印跳表中的所有节点 public void printAll() { Node p = head; while (p.forwards[0] != null) { System.out.println(p.forwards[0] + " "); p = p.forwards[0]; } System.out.println(); } } ``` 在跳表中，每个节点包含了一个数据域和一个数组，数组中存储了该节点在不同层级上的后继节点。在插入节点时，我们随机生成该节点的层数，并将其插入到每一层中适当的位置。在删除节点时，我们需要先查找到该节点的前驱节点，然后将其从每一层中删除即可。 这是一个简单的跳表实现，你可以根据自己的需求进行修改和扩展。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值