数据结构笔记之跳表（SkipList）

最新推荐文章于 2024-05-22 20:31:44 发布
最新推荐文章于 2024-05-22 20:31:44 发布
阅读量157 收藏
点赞数
文章标签： 数据结构与算法 java
原文链接：http://www.cnblogs.com/cc11001100/p/9801252.html
版权

 

一、跳表简述

跳表可以看做是一个带有索引的链表，在介绍跳表之前先看一下一个普通的链表，假如当前维护了一个有序的链表：

image

现在要在这个链表中查找128，因为事先不知道链表中数值的分布情况，我们只能从前到后依次遍历，那么有没有什么取巧的方法呢？

如果我们能够存储下最中间节点的引用，比如存储节点29的引用，然后每次要查找节点的时候就先跟29比较一下，如果比29小就还是从前往后找（因为不会超过中间节点，从前往后和从中间往前区别不大），如果比29大就直接跳到29开始往后找，这种思想就是为链表添加了一个简单的索引，一下可以节省掉一半的查找时间。跳表的设计思想类似，通过为链表的每个节点设置高度来添加索引，不同的高度称为不同的层，每一层的next只能指向当前层的下一个节点，下面是一个跳表的示例：

image

最左面一列null为head节点，用于保存每一层的第一个节点，在查找的时候先从最高层开始查找，比如要在上面的跳表中查找128：

image

首先取最高层第六层的next，是47，比128小，直接跳到47，然后47的第六层的next是null，说明到了最后一个了，层数减少，47的第五层的next是255，比128大，也不行，继续减少层数，47的第四层的next是255，依然比128大，继续减少层数，47的第三层的next是128，get it!

看上面的过程有没有意识到一个问题，就是如果跳表的层数过多的话”比较-降层“这个过程就会有不少的浪费，比如上面的在47这个节点进行了4次比较才找到了有效的next节点，如果这个值再大一点的话就会退化得很严重。那么这个层是如何来的呢，跳表的高度是通过一个随机数决定的，初始时默认为一层，然后一直产生随机数只要小于0.5就将层数加一层继续随机，但是随机这种东西毕竟是不可控的，为了避免出现过高的层数最好还是设置一个最大层数以免某些节点的层数过大。

 

二、跳表的实现

跳表的简单Java实现：

SkipList.java：

package alg.link;

import org.apache.commons.lang3.StringUtils;

/**
 * 跳表结构的简单Java实现
 *
 * @author CC11001100
 */
public class SkipList<T extends Comparable<T>> {

	private static final double DEFAULT_CONTINUE_INCREMENT_LEVEL_THRESHOLD = 0.75;
	private static final int DEFAULT_MAX_LEVEL = 10;

	// 用于控制层数，决定层数时当随机数小于此值时会一直升层直到最大，取值范围[0, 1]，值越大越可能得到高层数，此值设置不当很有可能退化成链表
	private double continueIncrementLevelThreshold;
	// 为了防止随机数出现异常情况过高，对最大层数做一个限制
	private int maxLevel;
	// 链表的头结点，每一层的头都保存在这里
	private Node<T> head;

	public SkipList() {
		this(DEFAULT_CONTINUE_INCREMENT_LEVEL_THRESHOLD, DEFAULT_MAX_LEVEL);
	}

	public SkipList(double threshold) {
		this(threshold, DEFAULT_MAX_LEVEL);
	}

	public SkipList(double threshold, int maxLevel) {
		this.continueIncrementLevelThreshold = threshold;
		this.maxLevel = maxLevel;
		this.head = new Node<>(null, 0);
		// 初始化时就将其扩充到最大避免后面扩容增加复杂性，只有head会浪费一些空间其它节点都是有几层申请多长的数组
		this.head.next = new Node[maxLevel];
	}

	public void add(T value) {
		Node[] previous = findPrevious(value);
		Node<T> node = new Node<>(value, randomLevel());
		for (int i = 0; i < previous.length && i < node.level; i++) {
			node.next[i] = previous[i].next[i];
			previous[i].next[i] = node;
		}
		if (node.level > head.level) {
			for (int i = node.level - 1; i >= 0 && head.next[i] == null; i--) {
				head.next[i] = node;
			}
			head.level = node.level;
		}
	}

	public void remove(T value) {
		Node[] previous = findPrevious(value);
		Node node = previous[0].next[0];
		if (node.value.compareTo(value) != 0) {
			return;
		}
		for (int i = 0; i < previous.length && i < node.level; i++) {
			previous[i].next[i] = node.next[i];
		}
	}

	public boolean contains(T value) {
		Node[] previous = findPrevious(value);
		Node node = previous[0].next[0];
		return node.value.compareTo(value) == 0;
	}

	private int randomLevel() {
		int level = 1;
		while (level < maxLevel && Math.random() < continueIncrementLevelThreshold) {
			level++;
		}
		return level;
	}

	private Node[] findPrevious(T value) {
		Node[] previous = new Node[head.level];
		Node<T> node = head;
		for (int i = head.level - 1; i >= 0; i--) {
			while (node.next[i] != null && node.next[i].value.compareTo(value) < 0) {
				node = node.next[i];
			}
			previous[i] = node;
		}
		return previous;
	}

	/**
	 * head_next   level_next                         # 注释，实际不会打印标题
	 * 67        	 	  	  	67
	 * 67        	 	  	  	67
	 * 67        	 	  	  	67
	 * 67        	 	  	  	67
	 * 19        	 	19	  	67
	 * 19        	 	19	  	67
	 * 6         	6	19	  	67
	 * 6         	6	19	  	67	82
	 * 6         	6	19	46	67	82
	 */
	public void show() {
		StringBuilder sb = new StringBuilder();
		for (int i = maxLevel; i > 0; i--) {
			// 这一层级的头指针指向谁
			Node levelHead = head.next[i - 1];
			if (levelHead != null) {
				sb.append(String.format("%-10s", levelHead.value.toString())).append("\t");
			} else {
				sb.append(StringUtils.repeat(" ", 10)).append("\t");
			}
			// 然后是每一层按层数是否出现打印value或空白填充
			Node node = head.next[0];
			while (node != null) {
				String s = node.value.toString();
				if (node.level >= i) {
					sb.append(s).append("\t");
				} else {
					sb.append(StringUtils.repeat(" ", s.length())).append("\t");
				}
				node = node.next[0];
			}
			if (i != 1) {
				sb.append("\n");
			}
		}
		System.out.println(sb.toString());
	}

	private static class Node<T extends Comparable<T>> {
		// 当前节点的值
		T value;
		// 当前节点的层数
		int level;
		// 记录当前节点在每一层的next节点
		Node<T>[] next;

		private Node(T value, int level) {
			this.value = value;
			this.level = level;
			this.next = new Node[level];
		}
	}

}

SkipListTest.java：

package alg.link;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

/**
 * @author CC11001100
 */
public class SkipListTest {

	public static void main(String[] args) {

		SkipList<Integer> skipList = new SkipList<>();
		Random random = new Random();
		List<Integer> numList = new ArrayList<>();
		for (int i = 0; i < 30; i++) {
			int n = random.nextInt(100);
			System.out.println("now insert " + n);
			skipList.add(n);
			skipList.show();
			numList.add(n);
			System.out.println("---------------------------------------------------------------------------");

			if (Math.random() < 0.5 && !numList.isEmpty()) {
				int removeNum = numList.remove(random.nextInt(numList.size()));
				System.out.println("now remove " + removeNum);
				skipList.remove(removeNum);
				skipList.show();
				System.out.println("---------------------------------------------------------------------------");
			}
		}

	}

}

测试效果：

now insert 35
          	  	
          	  	
          	  	
          	  	
          	  	
          	  	
          	  	
35        	35	
35        	35	
35        	35	
---------------------------------------------------------------------------
now insert 56
56        	  	56	
56        	  	56	
56        	  	56	
56        	  	56	
56        	  	56	
56        	  	56	
56        	  	56	
35        	35	56	
35        	35	56	
35        	35	56	
---------------------------------------------------------------------------
now remove 35
56        	56	
56        	56	
56        	56	
56        	56	
56        	56	
56        	56	
56        	56	
56        	56	
56        	56	
56        	56	
---------------------------------------------------------------------------
now insert 45
56        	  	56	
56        	  	56	
56        	  	56	
56        	  	56	
56        	  	56	
45        	45	56	
45        	45	56	
45        	45	56	
45        	45	56	
45        	45	56	
---------------------------------------------------------------------------
now remove 56
          	  	
          	  	
          	  	
          	  	
          	  	
45        	45	
45        	45	
45        	45	
45        	45	
45        	45	
---------------------------------------------------------------------------
now insert 7
          	 	  	
          	 	  	
          	 	  	
          	 	  	
          	 	  	
45        	 	45	
45        	 	45	
45        	 	45	
45        	 	45	
7         	7	45	
---------------------------------------------------------------------------
now insert 57
          	 	  	  	
          	 	  	  	
          	 	  	  	
          	 	  	  	
          	 	  	  	
45        	 	45	  	
45        	 	45	  	
45        	 	45	  	
45        	 	45	57	
7         	7	45	57	
---------------------------------------------------------------------------
now remove 7
          	  	  	
          	  	  	
          	  	  	
          	  	  	
          	  	  	
45        	45	  	
45        	45	  	
45        	45	  	
45        	45	57	
45        	45	57	
---------------------------------------------------------------------------
now insert 75
          	  	  	  	
          	  	  	  	
          	  	  	  	
          	  	  	  	
          	  	  	  	
45        	45	  	  	
45        	45	  	  	
45        	45	  	  	
45        	45	57	  	
45        	45	57	75	
---------------------------------------------------------------------------
now remove 75
          	  	  	
          	  	  	
          	  	  	
          	  	  	
          	  	  	
45        	45	  	
45        	45	  	
45        	45	  	
45        	45	57	
45        	45	57	
---------------------------------------------------------------------------
now insert 96
          	  	  	  	
          	  	  	  	
          	  	  	  	
          	  	  	  	
          	  	  	  	
45        	45	  	  	
45        	45	  	96	
45        	45	  	96	
45        	45	57	96	
45        	45	57	96	
---------------------------------------------------------------------------
now remove 96
          	  	  	
          	  	  	
          	  	  	
          	  	  	
          	  	  	
45        	45	  	
45        	45	  	
45        	45	  	
45        	45	57	
45        	45	57	
---------------------------------------------------------------------------
now insert 40
40        	40	  	  	
40        	40	  	  	
40        	40	  	  	
40        	40	  	  	
40        	40	  	  	
40        	40	45	  	
40        	40	45	  	
40        	40	45	  	
40        	40	45	57	
40        	40	45	57	
---------------------------------------------------------------------------
now remove 40
          	  	  	
          	  	  	
          	  	  	
          	  	  	
          	  	  	
45        	45	  	
45        	45	  	
45        	45	  	
45        	45	57	
45        	45	57	
---------------------------------------------------------------------------
now insert 69
          	  	  	  	
          	  	  	  	
          	  	  	  	
          	  	  	  	
          	  	  	  	
45        	45	  	  	
45        	45	  	  	
45        	45	  	69	
45        	45	57	69	
45        	45	57	69	
---------------------------------------------------------------------------
now insert 11
          	  	  	  	  	
          	  	  	  	  	
          	  	  	  	  	
          	  	  	  	  	
          	  	  	  	  	
45        	  	45	  	  	
11        	11	45	  	  	
11        	11	45	  	69	
11        	11	45	57	69	
11        	11	45	57	69	
---------------------------------------------------------------------------
now insert 19
          	  	  	  	  	  	
          	  	  	  	  	  	
          	  	  	  	  	  	
          	  	  	  	  	  	
          	  	  	  	  	  	
45        	  	  	45	  	  	
11        	11	  	45	  	  	
11        	11	  	45	  	69	
11        	11	19	45	57	69	
11        	11	19	45	57	69	
---------------------------------------------------------------------------
now insert 55
          	  	  	  	  	  	  	
          	  	  	  	  	  	  	
          	  	  	  	  	  	  	
          	  	  	  	  	  	  	
          	  	  	  	  	  	  	
45        	  	  	45	  	  	  	
11        	11	  	45	  	  	  	
11        	11	  	45	55	  	69	
11        	11	19	45	55	57	69	
11        	11	19	45	55	57	69	
---------------------------------------------------------------------------
now remove 55
          	  	  	  	  	  	
          	  	  	  	  	  	
          	  	  	  	  	  	
          	  	  	  	  	  	
          	  	  	  	  	  	
45        	  	  	45	  	  	
11        	11	  	45	  	  	
11        	11	  	45	  	69	
11        	11	19	45	57	69	
11        	11	19	45	57	69	
---------------------------------------------------------------------------
now insert 43
          	  	  	  	  	  	  	
          	  	  	  	  	  	  	
          	  	  	  	  	  	  	
          	  	  	  	  	  	  	
          	  	  	  	  	  	  	
45        	  	  	  	45	  	  	
11        	11	  	  	45	  	  	
11        	11	  	  	45	  	69	
11        	11	19	  	45	57	69	
11        	11	19	43	45	57	69	
---------------------------------------------------------------------------
now remove 43
          	  	  	  	  	  	
          	  	  	  	  	  	
          	  	  	  	  	  	
          	  	  	  	  	  	
          	  	  	  	  	  	
45        	  	  	45	  	  	
11        	11	  	45	  	  	
11        	11	  	45	  	69	
11        	11	19	45	57	69	
11        	11	19	45	57	69	
---------------------------------------------------------------------------
now insert 5
          	 	  	  	  	  	  	
          	 	  	  	  	  	  	
          	 	  	  	  	  	  	
          	 	  	  	  	  	  	
          	 	  	  	  	  	  	
45        	 	  	  	45	  	  	
11        	 	11	  	45	  	  	
11        	 	11	  	45	  	69	
11        	 	11	19	45	57	69	
5         	5	11	19	45	57	69	
---------------------------------------------------------------------------
now remove 5
          	  	  	  	  	  	
          	  	  	  	  	  	
          	  	  	  	  	  	
          	  	  	  	  	  	
          	  	  	  	  	  	
45        	  	  	45	  	  	
11        	11	  	45	  	  	
11        	11	  	45	  	69	
11        	11	19	45	57	69	
11        	11	19	45	57	69	
---------------------------------------------------------------------------
now insert 92
          	  	  	  	  	  	  	
          	  	  	  	  	  	  	
          	  	  	  	  	  	  	
          	  	  	  	  	  	  	
          	  	  	  	  	  	  	
45        	  	  	45	  	  	  	
11        	11	  	45	  	  	  	
11        	11	  	45	  	69	  	
11        	11	19	45	57	69	92	
11        	11	19	45	57	69	92	
---------------------------------------------------------------------------
now remove 45
          	  	  	  	  	  	
          	  	  	  	  	  	
          	  	  	  	  	  	
          	  	  	  	  	  	
          	  	  	  	  	  	
          	  	  	  	  	  	
11        	11	  	  	  	  	
11        	11	  	  	69	  	
11        	11	19	57	69	92	
11        	11	19	57	69	92	
---------------------------------------------------------------------------
now insert 56
          	  	  	  	  	  	  	
          	  	  	  	  	  	  	
          	  	  	  	  	  	  	
          	  	  	  	  	  	  	
          	  	  	  	  	  	  	
          	  	  	  	  	  	  	
11        	11	  	  	  	  	  	
11        	11	  	  	  	69	  	
11        	11	19	  	57	69	92	
11        	11	19	56	57	69	92	
---------------------------------------------------------------------------
now insert 31
          	  	  	  	  	  	  	  	
          	  	  	  	  	  	  	  	
          	  	  	  	  	  	  	  	
          	  	  	  	  	  	  	  	
          	  	  	  	  	  	  	  	
          	  	  	  	  	  	  	  	
11        	11	  	  	  	  	  	  	
11        	11	  	  	  	  	69	  	
11        	11	19	31	  	57	69	92	
11        	11	19	31	56	57	69	92	
---------------------------------------------------------------------------
now insert 29
          	  	  	  	  	  	  	  	  	
          	  	  	  	  	  	  	  	  	
          	  	  	  	  	  	  	  	  	
          	  	  	  	  	  	  	  	  	
          	  	  	  	  	  	  	  	  	
          	  	  	  	  	  	  	  	  	
11        	11	  	  	  	  	  	  	  	
11        	11	  	29	  	  	  	69	  	
11        	11	19	29	31	  	57	69	92	
11        	11	19	29	31	56	57	69	92	
---------------------------------------------------------------------------
now insert 96
          	  	  	  	  	  	  	  	  	  	
          	  	  	  	  	  	  	  	  	  	
          	  	  	  	  	  	  	  	  	  	
          	  	  	  	  	  	  	  	  	  	
          	  	  	  	  	  	  	  	  	  	
          	  	  	  	  	  	  	  	  	  	
11        	11	  	  	  	  	  	  	  	96	
11        	11	  	29	  	  	  	69	  	96	
11        	11	19	29	31	  	57	69	92	96	
11        	11	19	29	31	56	57	69	92	96	
---------------------------------------------------------------------------
now insert 0
          	 	  	  	  	  	  	  	  	  	  	
          	 	  	  	  	  	  	  	  	  	  	
          	 	  	  	  	  	  	  	  	  	  	
          	 	  	  	  	  	  	  	  	  	  	
          	 	  	  	  	  	  	  	  	  	  	
          	 	  	  	  	  	  	  	  	  	  	
11        	 	11	  	  	  	  	  	  	  	96	
0         	0	11	  	29	  	  	  	69	  	96	
0         	0	11	19	29	31	  	57	69	92	96	
0         	0	11	19	29	31	56	57	69	92	96	
---------------------------------------------------------------------------
now remove 19
          	 	  	  	  	  	  	  	  	  	
          	 	  	  	  	  	  	  	  	  	
          	 	  	  	  	  	  	  	  	  	
          	 	  	  	  	  	  	  	  	  	
          	 	  	  	  	  	  	  	  	  	
          	 	  	  	  	  	  	  	  	  	
11        	 	11	  	  	  	  	  	  	96	
0         	0	11	29	  	  	  	69	  	96	
0         	0	11	29	31	  	57	69	92	96	
0         	0	11	29	31	56	57	69	92	96	
---------------------------------------------------------------------------
now insert 54
          	 	  	  	  	  	  	  	  	  	  	
          	 	  	  	  	  	  	  	  	  	  	
          	 	  	  	  	  	  	  	  	  	  	
          	 	  	  	  	  	  	  	  	  	  	
          	 	  	  	  	  	  	  	  	  	  	
          	 	  	  	  	  	  	  	  	  	  	
11        	 	11	  	  	54	  	  	  	  	96	
0         	0	11	29	  	54	  	  	69	  	96	
0         	0	11	29	31	54	  	57	69	92	96	
0         	0	11	29	31	54	56	57	69	92	96	
---------------------------------------------------------------------------
now insert 8
          	 	 	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	
11        	 	 	11	  	  	54	  	  	  	  	96	
0         	0	 	11	29	  	54	  	  	69	  	96	
0         	0	 	11	29	31	54	  	57	69	92	96	
0         	0	8	11	29	31	54	56	57	69	92	96	
---------------------------------------------------------------------------
now remove 56
          	 	 	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	
11        	 	 	11	  	  	54	  	  	  	96	
0         	0	 	11	29	  	54	  	69	  	96	
0         	0	 	11	29	31	54	57	69	92	96	
0         	0	8	11	29	31	54	57	69	92	96	
---------------------------------------------------------------------------
now insert 60
          	 	 	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	
11        	 	 	11	  	  	54	  	  	  	  	96	
0         	0	 	11	29	  	54	  	  	69	  	96	
0         	0	 	11	29	31	54	57	  	69	92	96	
0         	0	8	11	29	31	54	57	60	69	92	96	
---------------------------------------------------------------------------
now insert 41
          	 	 	  	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	  	
41        	 	 	  	  	  	41	  	  	  	  	  	  	
11        	 	 	11	  	  	41	54	  	  	  	  	96	
0         	0	 	11	29	  	41	54	  	  	69	  	96	
0         	0	 	11	29	31	41	54	57	  	69	92	96	
0         	0	8	11	29	31	41	54	57	60	69	92	96	
---------------------------------------------------------------------------
now remove 92
          	 	 	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	
41        	 	 	  	  	  	41	  	  	  	  	  	
11        	 	 	11	  	  	41	54	  	  	  	96	
0         	0	 	11	29	  	41	54	  	  	69	96	
0         	0	 	11	29	31	41	54	57	  	69	96	
0         	0	8	11	29	31	41	54	57	60	69	96	
---------------------------------------------------------------------------
now insert 20
          	 	 	  	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	  	
41        	 	 	  	  	  	  	41	  	  	  	  	  	
11        	 	 	11	20	  	  	41	54	  	  	  	96	
0         	0	 	11	20	29	  	41	54	  	  	69	96	
0         	0	 	11	20	29	31	41	54	57	  	69	96	
0         	0	8	11	20	29	31	41	54	57	60	69	96	
---------------------------------------------------------------------------
now remove 41
          	 	 	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	
11        	 	 	11	20	  	  	54	  	  	  	96	
0         	0	 	11	20	29	  	54	  	  	69	96	
0         	0	 	11	20	29	31	54	57	  	69	96	
0         	0	8	11	20	29	31	54	57	60	69	96	
---------------------------------------------------------------------------
now insert 58
          	 	 	  	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	  	
11        	 	 	11	20	  	  	54	  	  	  	  	96	
0         	0	 	11	20	29	  	54	  	58	  	69	96	
0         	0	 	11	20	29	31	54	57	58	  	69	96	
0         	0	8	11	20	29	31	54	57	58	60	69	96	
---------------------------------------------------------------------------
now remove 31
          	 	 	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	
11        	 	 	11	20	  	54	  	  	  	  	96	
0         	0	 	11	20	29	54	  	58	  	69	96	
0         	0	 	11	20	29	54	57	58	  	69	96	
0         	0	8	11	20	29	54	57	58	60	69	96	
---------------------------------------------------------------------------
now insert 79
          	 	 	  	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	  	
11        	 	 	11	20	  	54	  	  	  	  	  	96	
0         	0	 	11	20	29	54	  	58	  	69	  	96	
0         	0	 	11	20	29	54	57	58	  	69	79	96	
0         	0	8	11	20	29	54	57	58	60	69	79	96	
---------------------------------------------------------------------------
now insert 38
          	 	 	  	  	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	  	  	
11        	 	 	11	20	  	  	54	  	  	  	  	  	96	
0         	0	 	11	20	29	  	54	  	58	  	69	  	96	
0         	0	 	11	20	29	38	54	57	58	  	69	79	96	
0         	0	8	11	20	29	38	54	57	58	60	69	79	96	
---------------------------------------------------------------------------
now insert 31
          	 	 	  	  	  	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	  	  	  	
11        	 	 	11	20	  	  	  	54	  	  	  	  	  	96	
0         	0	 	11	20	29	  	  	54	  	58	  	69	  	96	
0         	0	 	11	20	29	31	38	54	57	58	  	69	79	96	
0         	0	8	11	20	29	31	38	54	57	58	60	69	79	96	
---------------------------------------------------------------------------
now remove 79
          	 	 	  	  	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	  	  	
11        	 	 	11	20	  	  	  	54	  	  	  	  	96	
0         	0	 	11	20	29	  	  	54	  	58	  	69	96	
0         	0	 	11	20	29	31	38	54	57	58	  	69	96	
0         	0	8	11	20	29	31	38	54	57	58	60	69	96	
---------------------------------------------------------------------------
now insert 78
          	 	 	  	  	  	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	  	  	  	
          	 	 	  	  	  	  	  	  	  	  	  	  	  	  	
11        	 	 	11	20	  	  	  	54	  	  	  	  	78	96	
0         	0	 	11	20	29	  	  	54	  	58	  	69	78	96	
0         	0	 	11	20	29	31	38	54	57	58	  	69	78	96	
0         	0	8	11	20	29	31	38	54	57	58	60	69	78	96	
---------------------------------------------------------------------------
now remove 0
          	 	  	  	  	  	  	  	  	  	  	  	  	  	
          	 	  	  	  	  	  	  	  	  	  	  	  	  	
          	 	  	  	  	  	  	  	  	  	  	  	  	  	
          	 	  	  	  	  	  	  	  	  	  	  	  	  	
          	 	  	  	  	  	  	  	  	  	  	  	  	  	
          	 	  	  	  	  	  	  	  	  	  	  	  	  	
11        	 	11	20	  	  	  	54	  	  	  	  	78	96	
11        	 	11	20	29	  	  	54	  	58	  	69	78	96	
11        	 	11	20	29	31	38	54	57	58	  	69	78	96	
8         	8	11	20	29	31	38	54	57	58	60	69	78	96	
---------------------------------------------------------------------------

 

.

转载于:https://www.cnblogs.com/cc11001100/p/9801252.html

自我修炼的小石头
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
跳表（Skiplist）
AAAAgens的学习笔记
10-02 636
学习levelDB时，其Memtable使用到了Skiplist数据结构，在mongodb的存储引擎WiredTiger中的内存存储结构中也有使用。跳表(skip List)是一种随机化的数据结构，基于并联的链表，实现简单，插入、删除、查找的复杂度均为O(logn)，高度为O(logn)的概率较高，所需存储空间为O(n)。复杂度分析如下：
跳跃表 SkipList【数据结构】原理及实现
mfcheer
09-06 9244
为什么选择跳表目前经常使用的平衡数据结构有：B树，红黑树，AVL树，Splay Tree, Treep等。想象一下，给你一张草稿纸，一只笔，一个编辑器，你能立即实现一颗红黑树，或者AVL树出来吗？ 很难吧，这需要时间，要考虑很多细节，要参考一堆算法与数据结构之类的树，还要参考网上的代码，相当麻烦。用跳表吧，跳表是一种随机化的数据结构，目前开源软件 Redis 和 LevelDB 都有用到它，它的效率
【数据结构】跳跃链表(Skip list)
Damu
09-13 1016
普通的链表存在一个严重的缺陷： 需要顺序扫描才能找到所需要的元素。而且查找从链表的开头开始，只有找到了所需要的元素，或者直到链表的末尾都没有找到这个元素时才会停下来。将量表进行排序可以加速查找的过程，但是仍然需要顺序查找。因此，很容易想到，链表最好可以跳过某些节点，以避免顺序处理。 从而，引出了跳跃链表，跳跃链表是有序链表的一个有趣的变种，可以进行非顺序查找。 在有n个节点的跳跃链表中，对于
跳跃链表 skipList
weixin_33898876的博客
05-16 258
二分查找的速度已经很快了，在此基础上的跳跃链表是一种以空间换时间的思想。 1.跳跃链表的思想 1.元素有序。2.有多层，层数越高，元素之间的间隔interval越大。 3.每个元素有一个指向下层该元素的指针，downPointer。 2.查找过程 1.从顶层开始，二分查找待查元素。定位到插入位置而找不到元素，则往下一层从待插入位置开始新的二分查找。2....
skiplist跳表--一种高性能数据结构
akunshouyoudou的博客
02-12 425
数据库设计skiplist 更新于 2019-03-10约 4 分钟 skiplist简介 skip List是一种随机化的数据结构，基于并联的链表，实现简单，插入、删除、查找的复杂度均为O(logN)（大多数情况下），因为其性能匹敌红黑树且实现较为简单，因此在很多著名项目都用跳表来代替红黑树，例如LevelDB、Reddis的底层存储结构就是用的SkipList。 目前常用的...
test_高级数据结构lab6skiplist_
10-03
跳表是redis的一个核心组件，也同时被广泛地运用到了各种缓存地实现当中，它的主要优点，就是可以跟红黑树、AVL等平衡树一样，做到比较稳定地插入、查询与删除。理论插入查询删除的算法时间复杂度为O(logN)。
跳表SkipList的原理及实现
07-02
跳表是由William Pugh发明。他在 Communications of the ACM June 1990, 33(6) 668-676 发表了Skip lists: a probabilistic alternative to balanced trees，在该论文中详 细解释了跳表的数据结构和插入删除操作。
Go 语言中实现SkipList实现跳表.pdf
02-11
跳表 (Skip List) 是一种有序的链表数据结构，它通过在每个节点中存储多个指针，来提高查询效率。它的特点如下： 有序性：跳表中的元素是按照键值排序的，查询时可以利用这种有序性来加速查询速度。 动态的高度：...
基于图形处理器的高性能跳表(Skiplist)数据结构.pdf
08-07
#资源达人分享计划#
数据结构之跳表
03-18
数据结构之跳表的完整代码
Skip list----跳表
正经扯淡
07-27 744
Skip list(跳表）是一种可以代替平衡树的数据结构，默认是按照Key值升序的。Skip list让已排序的数据分布在多层链表中，以0-1随机数决定一个数据的向上攀升与否，通过“空间来换取时间”的一个算法，在每个节点中增加了向前的指针，在插入、删除、查找时可以忽略一些不可能涉及到的结点，从而提高了效率。 从概率上保持数据结构的平衡比显示的保持数据结构平衡要简单的多。对于大多数应用，用Skip
Mysql索引底层原理以及实战
huan100339的博客
09-10 181
一 InnoDb引擎局部性原理 在InnoDb中 数据会存储在磁盘中 在真正处理数据的时候先将数据加载到内存 表中读取某些纪录时 innodb引擎不需要把一条一条记录读取出来 innodb采用的方式 将数据划分为若干个也 以页作为磁盘和内存之间交互的基本单位 innodb中页大小一般为16kb大小 也就是说 当需要从磁盘中读取数据时每一次最少读取16kb的内容到内存中 每一次最少也会把内存中16kb数据写到磁盘中 （如果写记录数据过多的话会产生行溢出） 二 索引 ...
SkipList的那点事儿
weixin_34378922的博客
12-31 91
Skip List的工作原理 Skip List（跳跃表）是一种支持快速查找的数据结构，插入、查找和删除操作都仅仅只需要O(log n)对数级别的时间复杂度，它的效率甚至可以与红黑树等二叉平衡树相提并论，而且实现的难度要比红黑树简单多了。 Skip List主要思想是将链表与二分查找相结合，它维护了一个多层级的链表结构（用空间换取时间），可以把Skip List看作一个含有多个行的链表集合，每一...
力扣HOT100 - 1143. 最长公共子序列
qq_61504864的博客
05-20 292
【代码】力扣HOT100 - 1143. 最长公共子序列。
Day31 代码随想录打卡|二叉树篇---二叉树的递归遍历
m0_48909584的博客
05-19 465
因此我们递归函数的参数和返回值肯定是节点和返回结果的数组，终止条件是当遍历的节点为空，即遍历完时，单层遍历根据不同的遍历方式不同而确定。二叉树的前序遍历是中左右的顺序；中序遍历是左中右的顺序；后序遍历是左右中的顺序。利用递归写出二叉树的遍历时，我们一定要明确几个点，一是。利用递归的方式写出二叉树的前、中、后序遍历。
堆与堆排序算法实现分享
最新发布
Mrluo386的博客
05-22 217
在计算机科学中，堆是一种特殊的完全二叉树数据结构，常被用于实现优先队列等应用场景。本文将通过一个C语言示例，详细介绍如何实现一个基于数组的大顶堆及其基本操作——包括堆的创建、插入元素（入堆）、删除最大元素（出堆）以及利用这些操作实现堆排序算法。本代码实例主要涉及到了一个Heap结构体的定义、堆的创建、元素的插入与删除，以及堆排序的整个过程。
matlab模拟退火算法
weixin_45570158的博客
05-16 853
在MATLAB中实现退火算法（也称为模拟退火算法，Simulated Annealing, SA）通常涉及几个关键步骤：初始化系统状态、定义能量函数（或成本函数）、模拟退火过程（包括温度下降和状态转移）、以及判断是否达到停止条件。是一个结构体，包含了退火算法所需的参数，如最大迭代次数、初始温度、最终温度和温度衰减率等。函数只是一个示例，它需要根据具体问题的特点来生成新状态。也应该是一个计算给定状态下系统能量的函数。请注意，上述代码中的。
【动态规划】训练
m0_74183164的博客
05-21 234
这题硬币很像，就是判断条件不同。只有偶数才能转移。输入一个长为n的序列，输出这个序列最长上升子序列的长度。
使用c++设计skiplist数据结构
05-31
好的，我可以为您介绍一下使用C++设计skiplist数据结构的基本思路和实现方法。Skiplist是一种基于链表的数据结构，支持高效的查找、插入和删除操作，其核心思想是通过在链表中添加多级索引（即跳表），以实现快速查找的目的。 以下是一个简单的skiplist的C++实现代码： ```c++ #include <iostream> #include <cstdlib> #include <ctime> using namespace std; const int MAX_LEVEL = 16; // 定义skiplist的最大层数 // 定义节点结构体 struct Node { int value; Node **forward; // 存储每层索引的指针 Node(int level, int value) { this->value = value; forward = new Node*[level+1]; memset(forward, 0, sizeof(Node*)*(level+1)); } ~Node() { delete[] forward; } }; // 定义skiplist类 class SkipList { public: SkipList(); ~SkipList(); void insert(int value); void remove(int value); bool contains(int value); void print(); private: int level; Node *header; double probability() { return (double) rand() / RAND_MAX; } int randomLevel() { int lvl = 0; while (probability() < 0.5 && lvl < MAX_LEVEL) { lvl++; } return lvl; } }; // 初始化skiplist SkipList::SkipList() { level = 0; header = new Node(MAX_LEVEL, 0); srand(time(NULL)); } // 销毁skiplist SkipList::~SkipList() { if (header != NULL) { delete header; } } // 插入节点 void SkipList::insert(int value) { Node *update[MAX_LEVEL+1]; memset(update, 0, sizeof(Node*)*(MAX_LEVEL+1)); Node *x = header; for (int i = level; i >= 0; i--) { while (x->forward[i] != NULL && x->forward[i]->value < value) { x = x->forward[i]; } update[i] = x; } x = x->forward[0]; if (x == NULL || x->value != value) { int lvl = randomLevel(); if (lvl > level) { for (int i = level+1; i <= lvl; i++) { update[i] = header; } level = lvl; } x = new Node(lvl, value); for (int i = 0; i <= lvl; i++) { x->forward[i] = update[i]->forward[i]; update[i]->forward[i] = x; } } } // 删除节点 void SkipList::remove(int value) { Node *update[MAX_LEVEL+1]; memset(update, 0, sizeof(Node*)*(MAX_LEVEL+1)); Node *x = header; for (int i = level; i >= 0; i--) { while (x->forward[i] != NULL && x->forward[i]->value < value) { x = x->forward[i]; } update[i] = x; } x = x->forward[0]; if (x->value == value) { for (int i = 0; i <= level; i++) { if (update[i]->forward[i] != x) { break; } update[i]->forward[i] = x->forward[i]; } delete x; while (level > 0 && header->forward[level] == NULL) { level--; } } } // 查找节点 bool SkipList::contains(int value) { Node *x = header; for (int i = level; i >= 0; i--) { while (x->forward[i] != NULL && x->forward[i]->value < value) { x = x->forward[i]; } } x = x->forward[0]; return x != NULL && x->value == value; } // 打印skiplist void SkipList::print() { for (int i = 0; i <= level; i++) { Node *x = header->forward[i]; cout << "Level " << i << ": "; while (x != NULL) { cout << x->value << " "; x = x->forward[i]; } cout << endl; } } int main() { SkipList sl; sl.insert(1); sl.insert(2); sl.insert(3); sl.insert(5); sl.insert(4); sl.print(); sl.remove(3); sl.print(); cout << sl.contains(3) << endl; cout << sl.contains(5) << endl; return 0; } ``` 这里我们定义了一个Node结构体，用于存储skiplist中的节点信息，其中包括节点的值和每层索引的指针。然后我们定义了一个SkipList类，实现了插入、删除、查找和打印等操作。在插入操作中，我们使用随机数生成每个节点的层数，以实现跳表的效果；在删除操作中，我们首先查找到要删除的节点，然后按照相应的层数更新每层索引的指针，最后删除该节点即可。在查找操作中，我们从最高层逐层向下查找，直到找到目标节点或者遍历完整个skiplist。 希望这个简单的skiplist C++实现代码可以帮助您更好地理解和使用该数据结构。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值