跳表在Java中的实现

跳表Java 跳表(Skip List)是一种用于有序数据存储的数据结构,它在链表的基础上增加了多级索引,从而提高了查找、插入和删除操作的效率。跳表的平均时间复杂度为Ologn,与平衡二叉搜索树(如 AVL 树、红黑树)相当,但实现和维护相对简单。 阅读详情

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

语法:

跳表没有特定的语法,但它有一个算法。在研究算法之前,我们需要检查基本跳表操作的类型。

  1. 插入操作:在跳表中,用于在特定情况下向特定位置添加新节点
  2. 搜索操作:在跳表中,用于搜索特定节点
  3. 删除操作:在跳表中,用于删除特定情况下的节点

让我们看看跳表是如何以算法的方式工作的。

插入算法:

步骤1:确定节点级别,因为列表中的每个元素都由节点表示,并且在插入列表时随机选择节点的级别

步骤2:根据以下步骤确定节点的级别

步骤3:找到最大级别是跳表中级别计数的上限,该上限由 L(N)=logp/2N 确定。这确保了随机级别将大于最大级别

步骤4:插入从最高级别开始,并比较当前节点的下一个节点

步骤5:如果“下一个节点关键点”小于“插入的关键点”,则可以使用相同级别继续前进

步骤6:如果next node key大于inserted key,那么我们需要存储一个指向当前节点I的指针,并向下移动一级继续搜索。

搜索算法:

步骤1:因为搜索元素非常类似于搜索一个点以在跳表中插入元素。

步骤2:如果下一个节点键小于搜索键,那么我们可以在同一级别上前进

步骤3:如果next node key大于inserted key,那么我们需要存储一个指向当前节点I的指针,并向下移动一级继续搜索。

步骤4:在最低级别,如果最右侧元素的下一个元素具有与搜索键相等的键,那么我们已经找到了键,否则这是一个失败。

删除算法:

步骤1:要删除任何元素,比如k,首先我们需要使用搜索算法在跳表中定位该元素。

第2步:一旦我们使用搜索算法找到了元素,指针重新排列将从列表中删除该元素,就像我们在单个链接列表中所做的那样。

步骤3:我们需要从跳过列表的最低级别开始,重新排列I not元素k旁边的元素。

步骤4:删除元素后,可能会出现没有元素的级别的情况,因此我们需要通过减少跳表级别来删除这些级别。

示例:Java中的跳表

import java.util.Iterator;
import java.util.Random;
import java.util.NoSuchElementException;
public class SkipListJava<K extends Comparable<K>, V> implements Iterable<K> {
private int listsize;
private double pb;
protected static final Random randomGen = new Random();
protected static final double DEFAULT_PB = 0.5;
private NodeKeyValue<K, V> head;
public SkipListJava() {
this(DEFAULT_PB);
}
public SkipListJava(double pb) {
this.head = new NodeKeyValue<K, V>(null, null, 0);
this.pb = pb;
this.listsize = 0;
}
public V get(K key) {
checkKeyValid(key);
NodeKeyValue<K, V> listnode = findNode(key);
if (listnode.getKey().compareTo(key) == 0)
return listnode.getValue();
else
return null;
}
public void add(K key, V value) {
checkKeyValid(key);
NodeKeyValue<K, V> listnode = findNode(key);
if (listnode.getKey() != null && listnode.getKey().compareTo(key) == 0) {
listnode.setValue(value);
return;
}
NodeKeyValue<K, V> newlistNode = new NodeKeyValue<K, V>(key, value, listnode.getLevel());
horizontalInsertList(listnode, newlistNode);
int curLevel = listnode.getLevel();
int headlistLevel = head.getLevel();
while (isBuildLevel()) {
if (curLevel >= headlistLevel) {
NodeKeyValue<K, V> newHeadEle = new NodeKeyValue<K, V>(null, null, headlistLevel + 1);
verticalLink(newHeadEle, head);
head = newHeadEle;
headlistLevel = head.getLevel();
}
while (listnode.getUp() == null) {
listnode = listnode.getPrevious();
}
listnode = listnode.getUp();
NodeKeyValue<K, V> tmp = new NodeKeyValue<K, V>(key, value, listnode.getLevel());
horizontalInsertList(listnode, tmp);
verticalLink(tmp, newlistNode);
newlistNode = tmp;
curLevel++;
}
listsize++;
}
public void remove(K key) {
checkKeyValid(key);
NodeKeyValue<K, V> listnode = findNode(key);
if (listnode == null || listnode.getKey().compareTo(key) != 0)
throw new NoSuchElementException("Key does not exist!");
while (listnode.getDownList() != null)
listnode = listnode.getDownList();
NodeKeyValue<K, V> previous = null;
NodeKeyValue<K, V> next = null;
for (; listnode != null; listnode = listnode.getUp()) {
previous = listnode.getPrevious();
next = listnode.getNext();
if (previous != null)
previous.setNext(next);
if (next != null)
next.setPreviousVal(previous);
}
while (head.getNext() == null && head.getDownList() != null) {
head = head.getDownList();
head.setUp(null);
}
listsize--;
}
public boolean contains(K key) {
return get(key) != null;
}
public int listsize() {
return listsize;
}
public boolean empty() {
return listsize == 0;
}
protected NodeKeyValue<K, V> findNode(K key) {
NodeKeyValue<K, V> listnode = head;
NodeKeyValue<K, V> next = null;
NodeKeyValue<K, V> down = null;
K nodeKey = null;
while (true) {
next = listnode.getNext();
while (next != null && lessThanEqual(next.getKey(), key)) {
listnode = next;
next = listnode.getNext();
}
nodeKey = listnode.getKey();
if (nodeKey != null && nodeKey.compareTo(key) == 0)
break;
down = listnode.getDownList();
if (down != null) {
listnode = down;
} else {
break;
}
}
return listnode;
}
protected void checkKeyValid(K key) {
if (key == null)
throw new IllegalArgumentException("Key must be not null!");
}
protected boolean lessThanEqual(K a, K b) {
return a.compareTo(b) <= 0;
}
protected boolean isBuildLevel() {
return randomGen.nextDouble() < pb;
}
protected void horizontalInsertList(NodeKeyValue<K, V> a, NodeKeyValue<K, V> b) {
b.setPreviousVal(a);
b.setNext(a.getNext());
if (a.getNext() != null)
a.getNext().setPreviousVal(b);
a.setNext(b);
}
protected void verticalLink(NodeKeyValue<K, V> a, NodeKeyValue<K, V> b) {
a.setDown(b);
b.setUp(a);
}
@Override
public String toString() {
StringBuilder stringbuild = new StringBuilder();
NodeKeyValue<K, V> listnode = head;
while (listnode.getDownList() != null)
listnode = listnode.getDownList();
while (listnode.getPrevious() != null)
listnode = listnode.getPrevious();
if (listnode.getNext() != null)
listnode = listnode.getNext();
while (listnode != null) {
stringbuild.append(listnode.toString()).append("\n");
listnode = listnode.getNext();
}
return stringbuild.toString();
}
@Override
public Iterator<K> iterator() {
return new SkipListIterator<K, V>(head);
}
protected static class SkipListIterator<K extends Comparable<K>, V> implements Iterator<K> {
private NodeKeyValue<K, V> listnode;
public SkipListIterator(NodeKeyValue<K, V> listnode) {
while (listnode.getDownList() != null)
listnode = listnode.getDownList();
while (listnode.getPrevious() != null)
listnode = listnode.getPrevious();
if (listnode.getNext() != null)
listnode = listnode.getNext();
this.listnode = listnode;
}
@Override
public boolean hasNext() {
return this.listnode != null;
}
@Override
public K next() {
K result = listnode.getKey();
listnode = listnode.getNext();
return result;
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
}
protected static class NodeKeyValue<K extends Comparable<K>, V> {
private K key;
private V value;
private int skiplevel;
private NodeKeyValue<K, V> up, down, next, previous;
public NodeKeyValue(K key, V value, int skiplevel) {
this.key = key;
this.value = value;
this.skiplevel = skiplevel;
}
@Override
public String toString() {
StringBuilder stringbuild = new StringBuilder();
stringbuild.append("Node[")
.append("key:");
if (this.key == null)
stringbuild.append("None");
else
stringbuild.append(this.key.toString());
stringbuild.append(", value:");
if (this.value == null)
stringbuild.append("None");
else
stringbuild.append(this.value.toString());
stringbuild.append("]");
return stringbuild.toString();
}
public K getKey() {
return key;
}
public void setKey(K key) {
this.key = key;
}
public V getValue() {
return value;
}
public void setValue(V value) {
this.value = value;
}
public int getLevel() {
return skiplevel;
}
public void setLevel(int skiplevel) {
this.skiplevel = skiplevel;
}
public NodeKeyValue<K, V> getUp() {
return up;
}
public void setUp(NodeKeyValue<K, V> up) {
this.up = up;
}
public NodeKeyValue<K, V> getDownList() {
return down;
}
public void setDown(NodeKeyValue<K, V> down) {
this.down = down;
}
public NodeKeyValue<K, V> getNext() {
return next;
}
public void setNext(NodeKeyValue<K, V> next) {
this.next = next;
}
public NodeKeyValue<K, V> getPrevious() {
return previous;
}
public void setPreviousVal(NodeKeyValue<K, V> previous) {
this.previous = previous;
}
}
public static void main(String[] args) {
SkipListJava<Integer, String> skip = new SkipListJava<>();
for (int i = 20; i < 35; i++) {
skip.add(i, String.valueOf(i));
}
System.out.println(skip);
assert skip.listsize() == 10;
int count = 0;
for (Integer i : skip)
assert i.equals(count++);
skip.remove(23);
System.out.println(skip);
skip.remove(25);
skip.remove(33);
skip.remove(30);
System.out.println(skip);
skip.remove(28);
skip.add(25, "25");
System.out.println(skip);
assert skip.listsize() == 0;
assert skip.empty();
}
}

输出:

我们编写了此代码,用于添加到跳表、在跳表中搜索以及从跳表中删除。

小结

跳表的概念在任何编程语言中都是相同的,它是数据结构中的主要算法之一

 

java实现跳表 1.跳表的定义 跳表(SkipList):增加了向前指针的链表叫做指针。跳表全称叫做跳跃表,简称跳表。跳表是一个随机化的数据结构,实质是一种可以进行二分查找的有序链表。跳表在原有的有序链表上增加了多级索引,通过索引来实现快速查询。跳表不仅能提高搜索性能,同时也可以提高插入和删除操作的性能。 跳表是一个随机化的数据结构,可以被看做二叉树的一个变种,它在性能上和红黑树、AVL树不相上下,但是跳表的原理非常简单,目前在Redis和LevelDB中都有用到 2.跳表的详解 对于一个单链表来说,即使链表中的数据是有 阅读详情

相关推荐

Java实现跳表的数据结构与算法

跳表,即Skip List,是一种可以用来替代平衡树的数据结构。它通过在原始链表的基础上增加多级索引来提高查找效率。在跳表中,数据以节点的形式存储,并按照关键字的大小顺序排列。每个节点可以包含多个指向不同层级的指针,使得从最高层级开始的搜索可以在较短的时间内迅速定位到目标位置。在效率上,跳表因其能够减少查找时的节点访问次数,相比单一链表有显著的性能优势。例如,在一个有序链表中搜索一个元素需要平均比较N/2次,而在跳表中,这个数字随着层级的增加而减少,理想情况下,可以达到logN的效率。

weixin_31597759的博客 1021

跳表及其JAVA实现

跳表(Skip List)是一种基于链表的数据结构,它可以支持快速的查找、插入、删除操作,并且具有较好的平均时间复杂度,可以替代平衡树等复杂数据结构。/**数组存储每层索引的下一个节点。比如下标0表示链表本身,下标1表示第一层索引,依次类推。} }/**maxLevel 索引最大高度currentLevel 当前索引高度head 跳表头节点,从head查起} }i >= 0;} /**

u014775579的博客 1582

跳表(skiplist)Java实现

简单得实现跳表相关功能 SkipList<Integer> skipList = new SkipList<Integer>(maxLevel); 提供insert和seach接口 删除接口可做类似操作

跳表详解以及Java实现

redis zset原理——跳表数据结构详解,使用Java代码实现。

qq_44957574的博客 2265

【分享】获取微信通讯录python代码形式实现

微信号”, “昵称”, “地区”, “备注”, “标签”, “签名”, “来源”5. 找到最后一个空格所在的位置(后一个就是真正的联系人了)当前微信号与上一个相同的时候,说明到底部了,可以跳出循环。3. 滚动鼠标到最顶部(防止已经滚动了一部分了)7.记录下上一个联系人的微信号。7. 无限循环按键盘下箭头。获取详情中的以下元素内容。6. 点击第一个联系人。4. 获取联系人列表。

程序员老狼专注开发aigc或客服系统应用 2895

新手必看:手把手教你如何通过Github提交CVE漏洞(附完整截图流程)

本文为安全研究新手提供了一份详尽的CVE漏洞提交实战指南。文章重点介绍了如何通过Github平台,从漏洞发现、验证、撰写专业报告到最终提交CVE申请的全流程,并附有完整的截图和沟通模板,帮助初学者迈出负责任漏洞披露的第一步。

ttt77的博客 1257

Java JDK中的跳表实现

一、什么是Skip list(跳表) Skip list(跳表)是一种可以代替平衡树的数据结构,默认是按照Key值升序的。Skip list让已排序的数据分布在多层链表中,以0-1随机数决定一个数据的向上攀升与否,通过“空间来换取时间”的一个算法,在每个节点中增加了向前的指针,在插入、删除、查找时可以忽略一些不可能涉及到的结点,从而提高了效率。 从概率上保持数据结构的平衡比显示的保持数据结构平...

liinux-Talk is cheap,show me the code. 1122

R语言pls包实战:手把手教你用偏最小二乘(PLS)搞定高维数据回归(附完整代码与数据标准化避坑指南)

本文详细介绍了如何使用R语言的pls包进行偏最小二乘(PLS)回归分析,特别针对高维数据回归问题。通过完整的代码示例和数据标准化避坑指南,帮助读者掌握从数据预处理到模型优化的全流程,解决实际应用中的常见问题。

weixin_42662605的博客 352

跳表 在java中的实现 ConcurrentSkipListMap

转自:https://github.com/Snailclimb/JavaGuide/blob/master/docs/java/Multithread/并发容器总结.md 对于一个单链表,即使链表是有序的,如果我们想要在其中查找某个数据,也只能从头到尾遍历链表,这样效率自然就会很低,跳表就不一样了。跳表是一种可以用来快速查找的数据结构,有点类似于平衡树。它们都可以对元素进行快速的查找。但一个重要...

mulinsen77的博客 401

Unity Shader变体优化实战:从内存削减到打包加速

本文深入探讨了Unity项目中Shader变体数量爆炸导致的打包缓慢、内存占用过高及包体臃肿等问题。核心解决方案是通过精准的Shader变体裁剪,即收集项目实际用到的变体形成“白名单”,并利用IPreprocessShaders接口在打包时剔除无用变体。实战表明,该方法能显著提升打包速度并大幅降低运行时内存。

weixin_29300241的博客 218

Pyinstaller 打包 Pyzbar 时缺失 DLL 文件的排查与修复指南

本文详细解析了使用Pyinstaller打包Pyzbar库时,因缺失关键DLL文件导致程序闪退的常见问题。文章提供了从问题复现、错误诊断到最终修复的完整解决方案,核心在于通过修改.spec配置文件,手动将缺失的libzbar-64.dll等文件添加到打包过程中,确保生成的可执行文件能独立运行。

wdx012345的博客 504

跳表介绍和实现

想慢慢的给大家自然的引入跳表。 想想,我们 1)在有序数列里搜索一个数 2)或者把一个数插入到正确的位置 都怎么做? 很简单吧 对于第一个操作,我们可以一个一个比较,在数组中我们可以二分,这样比链表快 对于第二个操作,二分也没什么用,因为找到位置还要在数组中一个一个挪位置,时间复杂度依旧是o(n)。 那我们怎么发明一个查找插入都比较快的结构呢? 可以打...

少说,多做。 1万+

delphi fmx android 自动更新(一)

所以,如果是http 则,manifest.xml application 下,https无需添加。增加android:usesCleartextTraffic="true",不然无法使用http下载东西。1,REQUEST_INSTALL_PACKAGES 权限。4,WRITE_EXTERNAL_STORAGE 权限。3,READ_EXTERNAL_STORAGE 权限。一般是从http下载安装包 apk。2,INTERNET 权限。sFile为apk包路径。

全粘工程师 553

java 实现跳表

前言 最近在网上看到redis为什么用跳表而不用平衡树,觉得好奇就看了一下。 跳表的概念网上都有,这里就不赘述了。总的来说跳表相比于红黑树实现简单,并且支持范围查找。同时skiplist又无法归入哈希表、平衡树这两种用于查找的常见又高效的数据结构。所以动手实现了一个(主要是看到了实现简单)。 代码 /** * 此跳表用于有序存储节点并且查找指定权值节点的时间复杂度为O(logn) * * @...

FenG·的博客 955

092、多sensor帧同步在环视系统中的实现——基于瑞芯微RK3588的PPS同步与曝光同步方案

摘要: 本文探讨了瑞芯微RK3588平台在360环视系统中实现多摄像头帧同步的技术方案。针对环视拼接常见的动态场景错位问题,提出了PPS同步与曝光同步相结合的解决方案。通过GPIO硬件触发实现四路摄像头同步曝光,配合I2C全局曝光控制,将时间误差控制在0.5ms内。文章详细解析了RK3588设备树配置、内核驱动实现中的关键细节,包括同步信号处理、寄存器原子写入等核心技术点,并分享了量产中遇到的温度漂移、信号完整性等实际问题及解决方法。最终通过硬件整形和电源优化,将同步抖动控制在±5μs以内,有效解决了动态拼

zzfmlxs的博客 34

QGis二次开发 —— 1、win10/win11搭建Vs2017-QGis3.40.12环境(附Vs2017环境效果,附全部问题解决方法)(附:Qt助手加入QGis接口说明文档)

QGis二次开发 —— 1、Windows10搭建Vs2017-QGis环境(附Vs2017环境效果)(附:Qt助手加入QGisA接口说明文档)

1362

手写跳表 - Java

跳表是算法设计中简洁性和概率力量的有力证明。它为其核心操作实现了令人垂涎的OlognO(\\log n)Ologn平均时间性能,可与复杂的平衡树相媲美,但其实现却更直接、更容易理解。这段 Java 代码提供了一个极佳的、真实世界的例子,展示了如何从零开始构建一个跳表,并配备了泛型和数据持久化功能。它是每个开发者工具箱中一个强大的工具,也是算法优雅之美的一个完美例证。跳表是一种概率性数据结构,基于多层链表,每一层都是下一层的一个子集。

sss1513的博客 1111

Statistics and Machine Learning Toolbox

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

跳表的实现以及应用

最近在看Redis相关资料发现redis的存储类型中有一个是zset,zset很有意思,分为两种实现一种是基于压缩列表,另一种是基于跳表实现。

cz1803472613的博客 382

怀旧版电脑GBC模拟器

再现原版GBC掌机的界面,电脑运行连游戏界面都一样大小,很怀旧,很真实,(英文版)强烈推荐,很小的文件,很难才找到的。

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

跳表 SkipList

考虑到数据结构的可扩展性,结点的 Key 与 Value 均定义为泛型。其中 T key 继承Comparable接口,保证 key 可以用于比较排序,E Value 则用于存储结点的值。每个结点包含一个 forward 数组来存储索引中下一个索引结点的引用。该数组在初始化时,大小被设定为该结点的索引层数,以减少空间浪费。

SolitudeCoding的博客 1376

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

【数据结构】一文解析跳表

跳表是一种 的数据结构,随机性体现在跳表的层数是不固定的。跳表基于有序链表,可以在原始链表基础上创建多层索引架构,采用这种随机技术,跳表中的搜索、插入、删除操作的时间均为 。 上面就是跳表的图示,注意 h 节点是头结点,n 节点是尾结点,从图片来看本质就是一个链表加了 n 层来进行索引,跳表的查询流程等后面会逐步介绍的。大家在看到上面图片的时候也能想象,如果去掉 、、,其实跳表也就是一个链表,或者说是一个数组,但是加上之后,在做增删改查的时候就可以从上往下逐层查询查询,性能大大提高,所以查询性能才比较高

Jwasx的博客 1713

Java高手的30k之路|面试宝典|精通跳表SkipList

SkipList |代码实现|每一层节点选择的随机算法|新增/删除/查询|跳表的应用场景

weixin_41379244的博客 1055

手写一个简易跳表(Java版)

跳表概述 跳表是由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 deleti

TJtulong的博客 1204

跳表:为什么Redis一定要用跳表来实现有序集合

二分查找底层依赖的是数组随机访问的特性,所以只能用数组来实现。如果数据存储在链表中,就真的没法使用二分查找算法了吗?我们可以对链表稍加改造,就可以支持类似“二分”的查找算法。改造之后的数据结构叫作“跳表(Skip list)”跳表是各方面性能都比较优秀的,可以支持快速的插入、删除、查找操作,写起来不复杂,甚至可以替代红黑树(Red-black tree)。问题:Redis为什么会选择用跳表来实现有序集合呢?

贾欣晓的博客 327

20、redis底层实现跳表

一、简单介绍 1、我们为什么要使用跳表? 当我们使用对一个链表进行查找的时候,我们需要的时间复杂度是O(n)。我们没有办法对一个有序的链表进行二分查找。 当我们使用跳表实现,我们查找效率会很高,是O(logn)。 2、跳表的时间复杂度分析 每两个结点会抽出一个结点作为上一级索引的结点,那第一级索引的结点个数大约就是 n/2,第二级索引的结点个数大约就是 n/4,第三级索引的结点个数大约就...

沿海奔跑的少年 562

java跳表实现

java跳表实现 概念:一种有序链表,带有多级索引,查询性能为O(logN)。 运用:Redis,ConcurrentSkipListMap 这里主要参照了leetcode的实现,补充了泛型实现。 public class SkipList<T> { //当前层级 private int curentLevel = 1; //最大索引层级 private final static int MAX_LEVEL = 32; //队列头节点 private fin

星夜007的博客 285

java跳_java实现跳表

这两天利用java把跳表实现了下,利用java写的第二个数据结构,依旧很蛋疼囧...注:本人是边学边记,该代码大部分参考书上的c++源代码,但也有自己考虑过,因此虽然经过自己的较多检测,但还是不能完全确定没有bug,毕竟用的是别人的想法,还没完全变成自己的东西。如发现bug,请留言,我再修改:)代码贴上:import java.util.*;class JumpNode{public int va...

weixin_39940688的博客 157
上一篇: Java反序列化基础篇-JDK动态代理
下一篇: 【无标题】
javaYY_
博客等级 码龄4年 148粉丝 69原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值