【恋上数据结构】跳表（Skip List）原理及实现

最新推荐文章于 2024-02-25 12:22:17 发布
最新推荐文章于 2024-02-25 12:22:17 发布
阅读量759 收藏 2
点赞数
分类专栏： # 《恋上数据结构》 文章标签： 链表 数据结构 列表 算法 跳表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43734095/article/details/105780061
版权

跳表（Skip List）

数据结构与算法笔记：恋上数据结构笔记目录

引出跳表

一个有序链表搜索、添加、删除的平均时间复杂度是多少？

  • O(n)
    在这里插入图片描述

能否利用二分搜索优化有序链表，将搜索、添加、删除的平均时间复杂度降低至 O(logn)？

  • 链表没有像数组那样的高效随机访问（O(1) 时间复杂度），所以不能像有序数组那样直接进行二分搜索优化

有没有其他办法让有序链表搜索、添加、删除的平均时间复杂度降低至 O(logn)？

  • 跳表（SkipList）

跳表介绍

跳表，又叫做跳跃表、跳跃列表，在有序链表的基础上增加了“跳跃”的功能

  • 由 William Pugh 于1990年发布，设计的初衷是为了取代平衡树（比如红黑树）

Redis 中 的 SortedSet、LevelDB 中的 MemTable 都用到了跳表

  • Redis、LevelDB 都是著名的 Key-Value数据库

对比平衡树：

  • 跳表的实现和维护会更加简单
  • 跳表的搜索、删除、添加的平均时间复杂度是 O(logn)（与红黑树相同）

跳表原理及实现

使用跳表优化链表

普通链表：
在这里插入图片描述
有效层数为 2 的跳表：
在这里插入图片描述
有效层数为 4 的跳表：
在这里插入图片描述

跳表基础结构

/**
 * 跳表
 * @author yusael
 */
@SuppressWarnings("unchecked")
public class SkipList <K, V> {
	private static final double P = 0.25; // 仿照Redis的做法, 维护一个概率值
	private static final int MAX_LEVEL = 32; // 最高层数
	private int size;
	private Comparator<K> comparator;
	/**
	 * 有效层数
	 */
	private int level;
	/**
	 * 不存放任何 K-V 的虚拟头节点
	 */
	private Node<K, V> first; 
	
	public SkipList(Comparator<K> comparator) {
		this.comparator = comparator;
		// 头节点的高度必须是跳表的最高层数(非有效层数), 为了后面插入新节点做准备
		first = new Node<>(null, null, MAX_LEVEL);
	}
	
	private int compare(K k1, K k2) {
		return comparator != null
				? comparator.compare(k1, k2)
				: ((Comparable<K>)k1).compareTo(k2);
	}

	private static class Node<K, V> {
		K key;
		V value;
		Node<K, V>[] nexts; // 该节点的不同层指向的下一节点
		// 拿上面的四层跳表的图来举例
		// first.next[3] == 21节点
		// first.next[2] == 9节点
		// first.next[1] == 6节点
		// first.next[0] == 3节点
		public Node(K key, V value, int level) {
			this.key = key;
			this.value = value;
			nexts = new Node[level];
		}
	}

}

跳表的搜索

① 从顶层链表的首元素开始，从左往右搜索，直至找到一个大于或等于目标的元素，或者到达当前层链表的尾部
② 如果该元素等于目标元素，则表明该元素已被找到
③ 如果该元素大于目标元素或已到达链表的尾部，则退回到当前层的前一个元素，然后转入下一层进行搜索

public V get(K key) {
	keyCheck(key);
	
	Node<K, V> node = first;
	for (int i = level - 1; i >= 0 ; i--) {
		int cmp = -1;
		while (node.nexts[i] != null 
				&& (cmp = compare(key, node.nexts[i].key)) > 0) {
			node = node.nexts[i];
		}
		// node.nexts[i].key >= key
		if (cmp == 0) return node.nexts[i].value;
	}
	return null;
}

跳表的添加、删除

在这里插入图片描述
添加的细节：随机决定新添加元素的层数（官方建议）

/**
 * 跳表中加入新结点时的层数随机
 * @return
 */
private int randomLevel() {
	int level = 1; 
	while (Math.random() < P && level < MAX_LEVEL) { // 每次有25%的概率+1层
		level++;
	}
	return level;
}

public V put(K key, V value) {
	keyCheck(key);
	
	Node<K, V> node = first;
	// 前驱节点, 插入节点时要用到, 获取了前驱就相当于获取了后继
	Node<K, V>[] prevs = new Node[level];
	for (int i = level - 1; i >= 0 ; i--) {
		int cmp = -1;
		while (node.nexts[i] != null 
				&& (cmp = compare(key, node.nexts[i].key)) > 0) {
			node = node.nexts[i];
		}
		// node.nexts[i].key >= key
		if (cmp == 0) { // 节点原本就存在
			V oldV = node.nexts[i].value;
			node.nexts[i].value = value;
			return oldV;
		}
		prevs[i] = node; // 保存前驱节点
	}
		
	// 新节点的层数(随机)
	int newLevel = randomLevel();
	// 添加新节点
	Node<K, V> newNode = new Node<>(key, value, newLevel);
	// 设置新节点的前驱和后继(获取了前驱就相当于获取了后继)
	for (int i = 0; i < newLevel; i++) {
		if (i >= level) { // 新节点的层数比有效层数高
			// 头结点成为新节点的前驱
			first.nexts[i] = newNode; // 让头节点指向新节点(头节点创建时是最高层)
			// 后继结点默认指向null
		} else { // 新节点的层数比有效层数低
			newNode.nexts[i] = prevs[i].nexts[i]; // 让新节点的后继节点指向(之前的)前驱的后继
			prevs[i].nexts[i] = newNode; // 让前驱节点指向新节点
		}
	}
	level = Math.max(level, newLevel); // 计算跳表的最终层数(更新有效层数)
	size++; // 节点数量增加
	return null; // 之前不存在该节点, 返回null
}

删除的细节：删除一个元素后，整个跳表的层数可能会降低

public V remove(K key) {
	keyCheck(key);
	Node<K, V> node = first;
	Node<K, V>[] prevs = new Node[level];
	boolean exist = false; // 判断是否有该节点
	for (int i = level - 1; i >= 0; i--) {
		int cmp = -1;
		while (node.nexts[i] != null 
				&& (cmp = compare(key, node.nexts[i].key)) > 0) {
			node = node.nexts[i];
		}
		// key <= node.nexts[i].key 
		if (cmp == 0) exist = true; // 存在
		prevs[i] = node; // 保存前驱节点
	}
	if (!exist) return null; // 跳表中没有该元素, 无需删除
	
	// 需要被删除的节点
	// 此时该元素必然存在, 且node必然为最下面一层, 该元素的前驱节点 
	Node<K, V> removedNode = node.nexts[0];
	
	// 设置后继
	for (int i = 0 ; i < removedNode.nexts.length; i++) {
		prevs[i].nexts[i] = removedNode.nexts[i];
	}
	// 更新跳表的层数
	int newLevel = level;
	while (--newLevel > 0 && first.nexts[newLevel] == null) {
		level = newLevel;
	}
	size--; // 数量减少
	return removedNode.value;	 
}

跳表的层数

在这里插入图片描述

跳表的复杂度分析

每一层的元素数量：从下往上

  • 第 1 层链表固定有 n 个元素
  • 第 2 层链表平均有 n * p 个元素
  • 第 3 层链表平均有 n * p^2 个元素
  • 第 k 层链表平均有 n * p^k 个元素
  • ……

最高层的层数是 log1/p n，平均有个 1/p 元素

在搜索时，每一层链表的预期查找步数最多是 1/p

  • 所以总的查找步数是 -(logp n/p)
  • 时间复杂度是 O(logn)

跳表 - 完整源码

package com.mj;

import java.util.Comparator;

/**
 * 跳表
 * @author yusael
 */
@SuppressWarnings("unchecked")
public class SkipList <K, V> {
	private static final double P = 0.25; // 仿照Redis的做法, 维护一个概率值
	private static final int MAX_LEVEL = 32; // 最高层数
	private int size;
	private Comparator<K> comparator;
	/**
	 * 有效层数
	 */
	private int level;
	/**
	 * 不存放任何 K-V 的虚拟头结点
	 */
	private Node<K, V> first; 
	
	public SkipList(Comparator<K> comparator) {
		this.comparator = comparator;
		first = new Node<>(null, null, MAX_LEVEL);
	}
	
	public SkipList() {
		this(null);
	}
	
	public int size() {
		return size;
	}
	
	public boolean isEmpty() {
		return size == 0;
	}
	
	public V put(K key, V value) {
		keyCheck(key);
		
		Node<K, V> node = first;
		// 前驱节点, 插入节点时要用到, 获取了前驱就相当于获取了后继
		Node<K, V>[] prevs = new Node[level];
		for (int i = level - 1; i >= 0 ; i--) {
			int cmp = -1;
			while (node.nexts[i] != null 
					&& (cmp = compare(key, node.nexts[i].key)) > 0) {
				node = node.nexts[i];
			}
			// node.nexts[i].key >= key
			if (cmp == 0) { // 节点原本就存在
				V oldV = node.nexts[i].value;
				node.nexts[i].value = value;
				return oldV;
			}
			prevs[i] = node; // 保存前驱节点
		}
			
		// 新节点的层数(随机)
		int newLevel = randomLevel();
		// 添加新节点
		Node<K, V> newNode = new Node<>(key, value, newLevel);
		// 设置新节点的前驱和后继(获取了前驱就相当于获取了后继)
		for (int i = 0; i < newLevel; i++) {
			if (i >= level) { // 新节点的层数比有效层数高
				// 头结点成为新节点的前驱
				first.nexts[i] = newNode; // 让头节点指向新节点(头节点创建时是最高层)
				// 后继结点默认指向null
			} else { // 新节点的层数比有效层数低
				newNode.nexts[i] = prevs[i].nexts[i]; // 让新节点的后继节点指向(之前的)前驱的后继
				prevs[i].nexts[i] = newNode; // 让前驱节点指向新节点
			}
		}
		level = Math.max(level, newLevel); // 计算跳表的最终层数(更新有效层数)
		size++; // 节点数量增加
		return null; // 之前不存在该节点, 返回null
	}
	
	public V get(K key) {
		keyCheck(key);
		
		// first.next[3] == 21节点
		// first.next[2] == 9节点
		// first.next[1] == 6节点
		// first.next[0] == 3节点

		Node<K, V> node = first;
		for (int i = level - 1; i >= 0 ; i--) {
			int cmp = -1;
			while (node.nexts[i] != null 
					&& (cmp = compare(key, node.nexts[i].key)) > 0) {
				node = node.nexts[i];
			}
			// node.nexts[i].key >= key
			if (cmp == 0) return node.nexts[i].value;
		}
		return null;
	}
	
	public V remove(K key) {
		keyCheck(key);
		Node<K, V> node = first;
		Node<K, V>[] prevs = new Node[level];
		boolean exist = false; // 判断是否有该节点
		for (int i = level - 1; i >= 0; i--) {
			int cmp = -1;
			while (node.nexts[i] != null 
					&& (cmp = compare(key, node.nexts[i].key)) > 0) {
				node = node.nexts[i];
			}
			// key <= node.nexts[i].key 
			if (cmp == 0) exist = true; // 存在
			prevs[i] = node; // 保存前驱节点
		}
		if (!exist) return null; // 跳表中没有该元素, 无需删除
		
		// 需要被删除的节点
		// 此时该元素必然存在, 且node必然为最下面一层, 该元素的前驱节点 
		Node<K, V> removedNode = node.nexts[0];
		
		// 设置后继
		for (int i = 0 ; i < removedNode.nexts.length; i++) {
			prevs[i].nexts[i] = removedNode.nexts[i];
		}
		// 更新跳表的层数
		int newLevel = level;
		while (--newLevel > 0 && first.nexts[newLevel] == null) {
			level = newLevel;
		}
		size--; // 数量减少
		return removedNode.value;
	}
	
	/**
	 * 跳表中加入新结点时的层数随机
	 * @return
	 */
	private int randomLevel() {
		int level = 1; 
		while (Math.random() < P && level < MAX_LEVEL) { // 每次有25%的概率+1层
			level++;
		}
		return level;
	}
	
	private void keyCheck(K key) {
		if (key == null) {
			throw new IllegalArgumentException("key must not be null.");
		}
	}
	
	private int compare(K k1, K k2) {
		return comparator != null
				? comparator.compare(k1, k2)
				: ((Comparable<K>)k1).compareTo(k2);
	}

	private static class Node<K, V> {
		K key;
		V value;
		Node<K, V>[] nexts;
		public Node(K key, V value, int level) {
			this.key = key;
			this.value = value;
			nexts = new Node[level];
		}
		@Override
		public String toString() {
			return key + ":" + value + "_" + nexts.length;
		}
	}
	
	@Override
	public String toString() {
		StringBuilder sb = new StringBuilder();
		sb.append("一共" + level + "层").append("\n");
		for (int i = level - 1; i >= 0; i--) {
			Node<K, V> node = first;
			while (node.nexts[i] != null) {
				sb.append(node.nexts[i]);
				sb.append("\t");
				node = node.nexts[i];
			}
			sb.append("\n");
		}
		return sb.toString();
	}
}

测试代码：

package com.mj;

import java.util.TreeMap;
import com.mj.tool.Asserts;
import com.mj.tool.Times;

public class Main {
	public static void main(String[] args) {
//		SkipList<Integer, Integer> list = new SkipList<>();
//		test(list, 10, 10);
		time();
	}
	private static void time() {
		TreeMap<Integer, Integer> map = new TreeMap<>();
		SkipList<Integer, Integer> list = new SkipList<>();
		int count = 100_0000;
		int delta = 10;
		
		Times.test("SkipList", () -> {
			test(list, count, delta);
		});
		
		System.out.println("-----------------------");
		
		Times.test("TreeMap", () -> {
			test(map, count, delta);
		});
	}
	
	public static void test(SkipList<Integer, Integer> list, int count, int delta) {
		for (int i = 0; i < count; i++) {
			list.put(i, i + delta);
		}
//		System.out.println(list);
		for (int i = 0; i < count; i++) {
			Asserts.test(list.get(i) == i + delta);
		}
		Asserts.test(list.size() == count);
		for (int i = 0; i < count; i++) {
			Asserts.test(list.remove(i) == i + delta);
		}
		Asserts.test(list.size() == 0);
	}
	
	private static void test(TreeMap<Integer, Integer> map, int count, int delta) {
		for (int i = 0; i < count; i++) {
			map.put(i, i + delta);
		}
		for (int i = 0; i < count; i++) {
			Asserts.test(map.get(i) == i + delta);
		}
		Asserts.test(map.size() == count);
		for (int i = 0; i < count; i++) {
			Asserts.test(map.remove(i) == i + delta);
		}
		Asserts.test(map.size() == 0);
	}
	
}

一共4层
19:29_4	
4:14_3	19:29_4	
3:13_2	4:14_3	7:17_2	9:19_2	19:29_4	
0:10_1	1:11_1	2:12_1	3:13_2	4:14_3	5:15_1	6:16_1	7:17_2	8:18_1	9:19_2	10:20_1	11:21_1	12:22_1	13:23_1	14:24_1	15:25_1	16:26_1	17:27_1	18:28_1	19:29_4	

【SkipList】
耗时：0.451s(451.0ms)
-------------------------------------
【TreeMap】
耗时：0.383s(383.0ms)
-------------------------------------
萌宅鹿同学
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
跳表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) 是一种有序的链表数据结构，它通过在每个节点中存储多个指针，来提高查询效率。它的特点如下： 有序性：跳表中的元素是按照键值排序的，查询时可以利用这种有序性来加速查询速度。 动态的高度：...
详解高级数据结构之 跳表
小鱼学编程
07-22 7183
今天，我们来详细介绍一个高级数据结构---跳表
跳表skiplist
TABE_的博客
01-18 557
这里写目录标题跳表介绍查找操作插入操作删除操作概率均衡技术跳表性能跳表应用 跳表介绍 跳跃列表（也称跳表）是一种随机化数据结构，基于并联的链表，其效率可比拟于二叉查找树（对于大多数操作须要O(logn)平均时间）。 跳表是对有序的链表添加上附加的前进链接，添加是以随机化的方式进行的，所以在列表中的查找能够高速的跳过部分列表元素，因此得名。跳表的全部操作都以对数随机化的时间进行。 一个简单的跳表如下所示： 传统意义的单链表是一个线性结构，向有序的链表中插入一个节点须要O(n)的时间，查找操作须要O(n)的时
数据结构之：跳表
最新发布
www_tlj的专栏
02-25 2162
跳表（Skip List）是一种概率性数据结构，它通过在普通有序链表的基础上增加多级索引层来实现快速的查找、插入和删除操作。跳表的效率可以与平衡树相媲美，其操作的时间复杂度也是O(log n)，但跳表的结构更简单，更易于实现。
查找——图文翔解SkipList（跳跃表）
热门推荐
菜鸟的自留地-mooyang
06-09 1万+
跳跃表 跳跃列表（也称跳表）是一种随机化数据结构，基于并联的链表，其效率可比拟于二叉查找树（对于大多数操作需要O(logn)平均时间）。 基本上，跳跃列表是对有序的链表增加上附加的前进链接，增加是以随机化的方式进行的，所以在列表中的查找可以快速的跳过部分列表，因此得名。所有操作都以对数随机化的时间进行。 如上图所示，是一个即为简单的跳跃表。传统意义的单链表是一个线性结构，向有序的链表
数据结构-跳表
qq_29899535的博客
12-06 4608
一、跳表的基本概念 1、跳表的定义 跳表(SkipList)：增加了向前指针的链表叫做指针。跳表全称叫做跳跃表，简称跳表。跳表是一个随机化的数据结构，实质是一种可以进行二分查找的有序链表。跳表在原有的有序链表上增加了多级索引，通过索引来实现快速查询。跳表不仅能提高搜索性能，同时也可以提高插入和删除操作的性能。 跳表是一个随机化的数据结构，可以被看做二叉树的一个变种，它在性能上和红黑树、AVL树不相上下，但是跳表的原理非常简单，目前在Redis和LevelDB中都有用到。 2、跳表的详解 .
跳表（Skip List）
AN_ERA的博客
09-22 693
跳表（SkipList） 1. 跳表，又叫做跳跃表、跳跃列表，在有序链表的基础上增加了“跳跃”的功能 2. Redis中 的 SortedSet、LevelDB 中的 MemTable 都用到了跳表 3. 对比平衡树, 跳表的实现和维护会更加简单, 跳表的搜索、删除、添加的平均时间复杂度是 O(logn) 使用跳表优化链表 跳表的搜索 1. 从顶层链表的首元素开始，从左往右搜索，直至找到一个大于或等于目标的元素，或者到达当前层链表的尾部 2. 如果该元素等于目标元素，则表明该元素已被找到 3.
数据结构系列之跳表
felix
02-16 679
什么是跳表 跳表是一种数据结构。它允许快速查询一个有序连续元素的数据链表。跳跃列表的平均查找和插入时间复杂度都是O(log n)，优于普通队列的O(n)。 引题 线性表这种数据有两种具体实现, 数组和链表。具体的内容之前的文章里也有说过，可以翻翻看哇~。在这里两种数据结构中，数组的优点是查找速度快,而链表的优点是增删的效率高，这也是我们常说的。其实，非也。 数组是一种内存连续的数据结构,其优点是可以通过首地址+N*(sizeOf(Node)) 来快速获取指定位置上的元素.假如我们不知道指定元素的位置呢? 链
数据结构——跳跃表
aaaaaaaWoLan的博客
05-24 1195
跳跃表介绍 跳跃表（skiplist）是一种随机化的数据结构，是一种可以与平衡树媲美的层次化链表结构——查找、删除、添加等操作都可以在对数期望时间下完成，以下是一个典型的跳跃表例子： 到底有多随机，我们看了原理就知道了。 跳跃表原理 这里借助(1条消息) 跳跃表的原理和实现（Java）_CoderLucas的博客-CSDN博客_跳跃表原理和实现 中的图来讲解。 查找 假设当前我们要查找 39，我们要先从 head (第一层的第一个元素)开始查找： 39 > 负无穷，继续往后查找 39 >
test_高级数据结构lab6skiplist_
10-03
跳表是redis的一个核心组件，也同时被广泛地运用到了各种缓存地实现当中，它的主要优点，就是可以跟红黑树、AVL等平衡树一样，做到比较稳定地插入、查询与删除。理论插入查询删除的算法时间复杂度为O(logN)。
c++如何实现跳表（skiplist）
12-17
改造之后的数据结构叫作跳表。 定义 跳表是一个随机化的数据结构。它允许快速查询一个有序连续元素的数据链表。跳跃列表的平均查找和插入时间复杂度都是O(log n)，优于普通队列的O(n)。性能上和红黑树，AVL树...
基于图形处理器的高性能跳表(Skiplist)数据结构.pdf
08-07
#资源达人分享计划#
数据结构之跳表
zlx_code的专栏
05-27 6640
（1）、定义 跳表实际上是一种增加了前向指针的链表，是一种随机化的数据结构，实质上是可以进行二分查找的有序链表；跳表在原来的有序链表上加上了多级索引，通过索引来快速查找；可以支持快速的删除、插入和查找操作。 （2）、跳表的理解 对于一个单链表来讲，即使链表中存储的数据是有序的，如果我们想要在其中查找某个数据，也只能从头开到尾的遍历，查询效率低，时间复杂度是O(n)。如下图所示 如何提交...
数据结构---跳表
Djsnxbjans的博客
11-01 407
🚀跳表就是一个链表，与普通链表不同之处在于它存储的数据是有序的，更重要的一点是每个结点的高度是不固定的，高度不固定是指某个结点内部的next指针有多个，有的直线下一个结点，有的指向下下个结点，有的指向后面的某个结点。🚀如果跳表的所有结点是严格均匀分布的，那么很容易就能算出其查找效率是O(lgN)，但是跳表的结点高度是随机的，结点的排布也是任意的，那么他的查找效率又是多少呢？由于精确的计算出跳表的时间复杂度是较为复杂的，如果想要了解计算跳表效率的问题可以去看下跳表的作者William Pugh大佬的论文。
数据结构与算法-跳表详解
欢迎朋友，我是一名十多年开发经验的新手，希望多多指教。
06-06 1001
我们知道如果一个数组是有序的，查询的时候可以使用二分法进行查询，时间复杂度可以降到 O(logn) ，但如果链表是有序的，我们仍然是从前往后一个个查找，这样显然很慢，这个时候我们可以使用跳表（Skip list），跳表就是多层链表，每一层链表都是有序的，最下面一层是原始链表，包含所有数据，从下往上节点个数逐渐减少。
Redis-跳跃表（skip List）
养歌的博客
12-13 6999
什么是跳跃表（skip list） 跳表全称叫做跳跃表，简称跳表。跳表是一个随机化的数据结构， 跳跃表（skiplist）是一个用于有序元素序列快速搜索的随机化的数据结构，由美国计算机科学家William Pugh发明于1989年，论文《Skip lists: a probabilistic alternative to balanced trees》中提出。 它的效率和红黑树以及 AVL 树不相上下，但实现起来比较容易。是一种可以于平衡树媲美的层次化链表结构——查找、删除、添加等操作都可以在对数期望时间下
redis数据结构跳表
07-27
跳表（Skip List）是一种有序数据结构，它允许快速地查找、插入和删除元素。在 Redis 中，跳表常用于实现有序集合（Sorted Set）数据类型。 跳表的基本思想是通过在底层链表的基础上增加多层索引，从而提高查找效率...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

萌宅鹿同学

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值