Java 简单算法——单链表的使用

最新推荐文章于 2023-06-25 11:57:31 发布
最新推荐文章于 2023-06-25 11:57:31 发布
阅读量433 收藏 3
点赞数 1
分类专栏： 笔记 Java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HJS1453100406/article/details/106543374
版权
Java 同时被 3 个专栏收录
45 篇文章 1 订阅
订阅专栏
笔记
33 篇文章 0 订阅
订阅专栏
算法
7 篇文章 0 订阅
订阅专栏

原计划将这些内容写在单链表的后面，后想了想，它的篇幅已经很长了；
写博客最大的目的是为了以后方便回忆，既然如此，就再开一个新篇幅吧
毕竟我也不喜欢翻来翻去

单链表的简单使用

1.查找链表中倒数第K的元素

单链表不是不是双向链表，无法实现指针的返回，所以这一要求比较麻烦，但绝非实现不了；

思路：

①方法接收单链表的头节点（head）和要查找的值（K）
②遍历单链表中节点的个数（len）
③判断k是否合法（是否大于链表的长度/是否小于等于0）
④遍历寻找第（len-k）个元素

public class List {
    public static void main(String[] args){
        //创建链表
        Singlelist list =new Singlelist();

        //添加节点
       
        list.addByorder(new Node(1,"a"));
        list.addByorder(new Node(2,"b"));
        list.addByorder(new Node(3,"c"));
        list.addByorder(new Node(4,"d"));

        //显示链表
        list.show();
        //测试
        list.ListSeek(1);
        list.ListSeek(5);
        list.ListSeek(3);

    }
}
class Singlelist {
    public  Node head=new Node(0," ");//创建头节点;

    public void addByorder(Node a){
        Node temp2=head;
        boolean f=true;//是否可以添加

        while (true){
            if (temp2.Next==null) break;
            else if(temp2.Next.no==a.no) {temp2.Next.name=a.name;f=false;break;}//新元素覆盖
            else if (temp2.Next.no>a.no) break;

            temp2= temp2.Next;
        }
        if (f){
            a.Next=temp2.Next;
            temp2.Next=a;
        }

    }

    //显示链表
    public void show(){
        //先判度链表是否为空
        if(head.Next==null) {System.out.println("链表无数据");return;}

        Node temp1=head.Next;//头节点不打印

        while(temp1.Next!=null){
            System.out.print(temp1+" --> ");//为了输出结果好看，这里做了一些处理
            temp1=temp1.Next;
        } System.out.println(temp1);

    }

    //新建:判断有效元素个数的方法
    public  int Listlen(){
        Node temp=head;
        int k=0;
        while(temp.Next!=null){
            k++;
            temp=temp.Next;
        }
        return k;
    }

    //新建：寻找倒数第k个元素
    public  void ListSeek(int k){
        int len=Listlen();
        if (len<k || k<=0) {System.out.println("要查询的值超出链表有效长度");return;}
        Node temp=head;

        for (int i=0;i<=len-k;i++){
            temp=temp.Next;
        }
        System.out.printf("倒数第%d个元素是%s\n",k,temp.name);

    }

}
class Node{
    public int no;
    public String name;
    public Node Next;

    public Node(int no,String name){
        this.no=no;
        this.name=name;
    }

    @Override
    public String toString() {
        return no+"="+name;
    }
}

测试结果：
在这里插入图片描述

2.反转链表

一开始想用"折半交换"的方法，但是后来想想单链表没有可靠的‘连续顺序’作为引子，果断放弃；不过想到了另一种方法；

思路：

①定义一个新的链表（头结点）；
②遍历原来的链表，依次取出节点；
③每取出一个节点元素就放置到新链表的最前面；
④将新链表的头节点更换为就链表的头节点；

public class List {
    public static void main(String[] args){
        //创建链表
        Singlelist list =new Singlelist();

        //添加节点
       
        list.addByorder(new Node(1,"a"));
        list.addByorder(new Node(2,"b"));
        list.addByorder(new Node(3,"c"));
        list.addByorder(new Node(4,"d"));

        //显示链表
        list.show();
        list.ListReversal();
        list.show();


    }
}
class Singlelist {
    public  Node head=new Node(0," ");//创建头节点;

    public void addByorder(Node a){
        Node temp2=head;
        boolean f=true;//是否可以添加

        while (true){
            if (temp2.Next==null) break;
            else if(temp2.Next.no==a.no) {temp2.Next.name=a.name;f=false;break;}//新元素覆盖
            else if (temp2.Next.no>a.no) break;

            temp2= temp2.Next;
        }
        if (f){
            a.Next=temp2.Next;
            temp2.Next=a;
        }

    }

    //显示链表
    public void show(){
        //先判度链表是否为空
        if(head.Next==null) {System.out.println("链表无数据");return;}

        Node temp1=head.Next;//头节点不打印

        while(temp1.Next!=null){
            System.out.print(temp1+" --> ");//为了输出结果好看，这里做了一些处理
            temp1=temp1.Next;
        } System.out.println(temp1);


    }

    //新建：反转链表
    public void ListReversal(){
        Node Newhead=new Node(0,"");//定义一个新的头节点
        Node next=null;//表示反转以后节点后接的元素，第一个元素后接null
        Node temp=head.Next;//头节点不能移动，替代指针,并且头节点不参与反转;

        //如果链表为空或者只有一个元素，则返回原链表
        if (temp==null || temp.Next==null) return;

        while(temp!=null){
            next=temp.Next;//保存当前节点的下一个节点;
            temp.Next=Newhead.Next;//旧链表中第二个节点执行新链表中首位
            Newhead.Next=temp;//结合上面，旧链表中第一个节点放在旧链表中第二个节点的后面
            temp = next;//后移
        }
        head.Next=Newhead.Next;


    }


}
class Node{
    public int no;
    public String name;
    public Node Next;

    public Node(int no,String name){
        this.no=no;
        this.name=name;
    }

    @Override
    public String toString() {
        return no+"="+name;
    }
}

输出结果：
在这里插入图片描述

3.单链表的逆序打印

这道题的方式我想到了俩个（应该有很多）：
方法一：使用上面的单链表反转后打印，但是这样会破坏原链表；
方法二：使用栈，利用栈先进后出的特点；

关于栈的概念放到以后再说，现在先在这里使用一下即可；

思路：将链表中的所有数据压入栈，后从栈里取出；

import java.util.Stack;//栈的头文件

public class List {
    public static void main(String[] args){
        //创建链表
        Singlelist list =new Singlelist();


        //添加节点
       
        list.addByorder(new Node(1,"a"));
        list.addByorder(new Node(2,"b"));
        list.addByorder(new Node(3,"c"));
        list.addByorder(new Node(4,"d"));

        //显示链表
        list.show();

        //测试逆序打印单链表
        list.ListStack(list.head);

    }
}
class Singlelist {
    public  Node head=new Node(0," ");//创建头节点;

    public void addByorder(Node a){
        Node temp2=head;
        boolean f=true;//是否可以添加

        while (true){
            if (temp2.Next==null) break;
            else if(temp2.Next.no==a.no) {temp2.Next.name=a.name;f=false;break;}//新元素覆盖
            else if (temp2.Next.no>a.no) break;

            temp2= temp2.Next;
        }
        if (f){
            a.Next=temp2.Next;
            temp2.Next=a;
        }

    }

    //显示链表
    public void show(){
        //先判度链表是否为空
        if(head.Next==null) {System.out.println("链表无数据");return;}

        Node temp1=head.Next;//头节点不打印

        while(temp1.Next!=null){
            System.out.print(temp1+" --> ");//为了输出结果好看，这里做了一些处理
            temp1=temp1.Next;
        } System.out.println(temp1);


    }

    //新建：逆序输出单链表
    public  void ListStack(Node a){
        if (a.Next==null) {System.out.println("该链表当前为空，不可逆序");return;}
        Stack <Node> stack=new Stack<Node>();//生成一个栈，规定传入类型为Node

        Node b=a.Next;

        while(b!=null){
            stack.push(b);//将链表中所有节点压入栈;
            b=b.Next;//后移指针
        }

        while(stack.size()>1){//根据栈内的元素判断出栈次数（为了输出效果我把这里改成了1）
            System.out.print(stack.pop()+" --> ");//出栈

        }System.out.println(stack.pop());

    }


}
class Node{

    public int no;
    public String name;
    public Node Next;

    public Node(int no,String name){
        this.no=no;
        this.name=name;
    }

    @Override
    public String toString() {
        return no+"="+name;
    }
}

测试结果：
在这里插入图片描述

4.合并两个有序单链表

要求是合并两个有序单链表，是其合并完以后仍然有序；

主思路：利用分治；

辅思路有两种：

第一种：使用递归

①重写show方法，其实可以传入节点后输出；
②比较数据，将较小的数据放入一个不带头节点的链表中；
③利用递归重复第二步，完成所有的比较；

public class List {
    public static void main(String[] args) {
        //创建链表
        Singlelist list = new Singlelist();
        Singlelist list1 = new Singlelist();
        Singlelist list2 = new Singlelist();

        //添加节点
        list.addByorder(new Node(1, "a"));
        list.addByorder(new Node(2, "c"));
        list.addByorder(new Node(3, "e"));
        list.addByorder(new Node(4, "g"));

        list1.addByorder(new Node(1, "b"));
        list1.addByorder(new Node(2, "d"));
        list1.addByorder(new Node(3, "f"));
        list1.addByorder(new Node(4, "h"));

        //显示链表
        list.show();
        list1.show();
        list2.show(list2.Listmerge(list.head.Next,list1.head.Next));
    }
}

class Singlelist {
    public Node head = new Node(0, " ");//创建头节点;
    public void addByorder(Node a) {
        Node temp2 = head;
        boolean f = true;//是否可以添加
        while (true) {
            if (temp2.Next == null) break;
            else if (temp2.Next.no == a.no) {
                temp2.Next.name = a.name;
                f = false;
                break;
            }//新元素覆盖
            else if (temp2.Next.no > a.no) break;
            temp2 = temp2.Next;
        }
        if (f) {
            a.Next = temp2.Next;
            temp2.Next = a;
        }
    }
    //显示链表
    public void show() {
        //先判度链表是否为空
        if (head.Next == null) {
            System.out.println("链表无数据");
            return;
        }

        Node temp1 = head.Next;//头节点不打印

        while (temp1.Next != null) {
            System.out.print(temp1 + " --> ");//为了输出结果好看，这里做了一些处理
            temp1 = temp1.Next;
        }
        System.out.println(temp1);
    }
    public void show(Node a) {
        //先判度链表是否为空
        if (a.Next == null) {
            System.out.println("链表无数据");
            return;
        }

        Node temp1 = a;//无头节点

        while (temp1.Next != null) {
            System.out.print(temp1 + " --> ");
            temp1 = temp1.Next;
        }
        System.out.println(temp1);
    }

    //合并链表(递归方式)
    public   Node Listmerge(Node a, Node b) {
       if (a == null || b == null){
            return a!=null ? a:b;
        }
        Node head;
        if (a.no<=b.no){
            head=a;
            head.Next=Listmerge(a.Next,b);
        }else
        {
            head=b;
            head.Next=Listmerge(a,b.Next);
        }
        return head;
    }
}

class Node {
    public int no;
    public String name;
    public Node Next;
    public Node(int no, String name) {
        this.no = no;
        this.name = name;
    }
    @Override
    public String toString() {
        return no + "=" + name;
    }
}

输出结果：
在这里插入图片描述
第二种：非递归

①接收到的链表为a和b
②新建一个节点head，指向首元素小的链表a（此处是head）
③将head所在的链表视为主链表（a），另外一个视为次链表（b）
④如果主链表中的元素小于次链表中的元素（a<b）则直接将链表指针后移
⑤如果第④步结论相反，则将次链表中的元素插入到主链表中

//合并链表(非递归)
    public   Node Listmerge(Node a, Node b) {
        if (a == null || b == null){//如果有一个链表为空，直接返回另外一个链表
            return a!=null ? a:b;
        }

        Node head= (a.no < b.no ?a:b);//head指向a和b中首元素最小的链表

        Node cur1= head == a ? a : b;//cur1指向a和b中首元素最小的链表
        //此时cur1与head操作的为同一块内存区域
        Node cur2= head == a ? b : a;//cur2指向a和b中首元素最小的链表

        Node pre=null;//cur1的前一个元素
        Node next=null;//cur2的后一个元素

        while(cur1!=null && cur2!=null){
            //无论怎么样第一步先走这里
            if (cur1.no<=cur2.no){//1.如果cur1中的元素小于cur2
                pre=cur1;//2.保存当前最小元素
                cur1=cur1.Next;//3.指针直接后移
            }else{
                next=cur2.Next;//1.next保存当前cur2中的当前最小值的下一个元素
                //插入开始
                pre.Next=cur2;//2.将cur2连接到上一个最小元素的后面
                cur2.Next=cur1;//3.cur2后面连接上一个最小元素的后面的元素
                pre=cur2;//4.保存当前最小元素
                cur2=next;//5，将cur2指向刚刚保存的next
            }
        }
        pre.Next = cur1 == null ? cur2 : cur1;//如果有一个链表为空，另一个链表直接接在后面；
        return head;//由于操作的是同一片区域，所以可以直接输出head
    }
}

完整代码：

public class List {
    public static void main(String[] args) {
        //创建链表
        Singlelist list = new Singlelist();
        Singlelist list1 = new Singlelist();
        Singlelist list2 = new Singlelist();

        //添加节点
        list.addByorder(new Node(1, "a"));
        list.addByorder(new Node(2, "c"));
        list.addByorder(new Node(3, "e"));
        list.addByorder(new Node(4, "g"));

        list1.addByorder(new Node(3, "b"));
        list1.addByorder(new Node(4, "d"));
        list1.addByorder(new Node(5, "f"));
        list1.addByorder(new Node(6, "h"));

        //显示链表
        list.show();
        list1.show();
        list2.show(list2.Listmerge(list.head.Next,list1.head.Next));

    }

}

class Singlelist {
    public Node head = new Node(0, " ");//创建头节点;

    public void addByorder(Node a) {
        Node temp2 = head;
        boolean f = true;//是否可以添加

        while (true) {
            if (temp2.Next == null) break;
            else if (temp2.Next.no == a.no) {
                temp2.Next.name = a.name;
                f = false;
                break;
            }//新元素覆盖
            else if (temp2.Next.no > a.no) break;

            temp2 = temp2.Next;
        }
        if (f) {
            a.Next = temp2.Next;
            temp2.Next = a;
        }

    }

    //显示链表
    public void show() {
        //先判度链表是否为空
        if (head.Next == null) {
            System.out.println("链表无数据");
            return;
        }

        Node temp1 = head.Next;//头节点不打印

        while (temp1.Next != null) {
            System.out.print(temp1 + " --> ");//为了输出结果好看，这里做了一些处理
            temp1 = temp1.Next;
        }
        System.out.println(temp1);
    }
    public void show(Node a) {
        //先判度链表是否为空
        if (a.Next == null) {
            System.out.println("链表无数据");
            return;
        }

        Node temp1 = a;//头节点不打印

        while (temp1.Next != null) {
            System.out.print(temp1 + " --> ");//为了输出结果好看，这里做了一些处理
            temp1 = temp1.Next;
        }
        System.out.println(temp1);


    }

    //合并链表(非递归)
    public   Node Listmerge(Node a, Node b) {
        if (a == null || b == null){//如果有一个链表为空，直接返回另外一个链表
            return a!=null ? a:b;
        }

        Node head= (a.no < b.no ?a:b);//head指向a和b中首元素最小的链表

        Node cur1= head == a ? a : b;//cur1指向a和b中首元素最小的链表
        //此时cur1与head操作的为同一块内存区域
        Node cur2= head == a ? b : a;//cur2指向a和b中首元素最小的链表

        Node pre=null;//cur1的前一个元素
        Node next=null;//cur2的后一个元素

        while(cur1!=null && cur2!=null){
            //无论怎么样第一步先走这里
            if (cur1.no<=cur2.no){//1.如果cur1中的元素小于cur2
                pre=cur1;//2.保存当前最小元素
                cur1=cur1.Next;//3.指针直接后移
            }else{
                next=cur2.Next;//1.next保存当前cur2中的当前最小值的下一个元素
                //插入开始
                pre.Next=cur2;//2.将cur2连接到上一个最小元素的后面
                cur2.Next=cur1;//3.cur2后面连接上一个最小元素的后面的元素
                pre=cur2;//4.保存当前最小元素
                cur2=next;//5，将cur2指向刚刚保存的next
            }
        }
        pre.Next = cur1 == null ? cur2 : cur1;//如果有一个链表为空，另一个链表直接接在后面；
        return head;//由于操作的是同一片区域，所以可以直接输出head
    }
}

class Node {
    public int no;
    public String name;
    public Node Next;

    public Node(int no, String name) {
        this.no = no;
        this.name = name;
    }


    @Override
    public String toString() {
        return no + "=" + name;
    }
}

在这里插入图片描述

特别鸣谢：橙子小姐姐

Jiashun Hao
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java 单列集合List 万字详解（通俗易懂）
Cyan_RA9的博客
11-20 1965
java 集合之List接口，是集合篇章重要的一部分。
Java集合之单列集合
qq_52146944的博客
05-06 1002
迭代器源码分析。
Java实现单向链表
you do ,you win
04-20 2290
文章目录单向链表的特点主要属性及方法size节点类Node方法节点的添加节点的删除节点数据的获取链表的遍历实现细节测试 单向链表的特点 单向链表，见名知意，即单向存储的链表。由一个个节点链接而成，每个节点保存当前节点存储的数据以及下一个节点的位置（由于java中淡化了指针这个概念，此处我们可以理解为保存下一个节点）每个节点只知道后继节点是谁，而不清楚自己的上一个前驱节点（就像间谍一样，老大能找到你，但你不能去找老大） 主要属性及方法 size 代表链表中节点的数量 节点类Node 属性：T data、Nod
java数据结构（一）单链表插入查找删除
fjf_666的博客
06-25 432
单列表插入查找删除算法实现
JAVA 单链表的实现
LYE_LYE的博客
08-29 359
JAVA单链表的实现
小白算法积累——单链表15#2个带头结点单链表+提取公共元素+二表合一
01-20
关键字：2个带头结点单链表+提取公共元素+二表合一 思路 二表合一：采用**“归并”的思想，设置两个工作指针pa和pb，对两个链表进行归并扫描，只有同时出现在两集合中的元素才链接到结果表**中， 这里是新A表。并且...
数据结构——单链表实验
06-15
1.实验目的 熟悉单链表的定义，单链表的建立方法及相关基本操作，理解单链表的基本思想，能够根据实际情况选择合适的存储结构。...4、编写算法将这两个单链表归并为一个按元素值递减次序排列的单链表并计算表长。
java动态规划算法——硬币找零问题实例分析
08-19
主要介绍了java动态规划算法——硬币找零问题,结合实例形式分析了java动态规划算法——硬币找零问题相关原理、实现方法与操作注意事项,需要的朋友可以参考下
算法实现：Java单链表逆序
09-01
有一次，我去陆家嘴一家银行面试，面试官给我出了一道算法编程题，用Java实现单链表逆序，不到10分钟，我就写出来了，拿到了offer。 但是当时是写在纸上的，我用手机拍了下来，然后回去又在电脑上把代码敲了下来，...
Java算法篇-单链表反转详解.pptx.pptx
最新发布
12-21
单链表的定义 单链表是一种线性数据结构，它包含一系列的节点，每个节点都含有一个值和指向下一个节点的引用。 单链表的特性 单链表具有动态性，可以灵活地插入和删除元素，但访问元素时需要从头节点开始顺序查找。 ...
SingleList.java
10-15
SingleList.java
[Data structure]单链表 | 一文介绍线性数据结构之一的单链表(Java实现)
逐梦苍穹的博客
04-29 1291
单链表（Singly linked list）是一种常见的线性数据结构，它由若干个节点组成，每个节点都包含数据元素和一个指向下一个节点的指针。
学习记录 --- java实现单链表（简单的学生信息的增删改）
weixin_43919497的博客
05-19 1444
1. 创建节点 节点里的数据一般分为数据节点、和指向下一个节点的变量（指针）。 class StuNode{ public int no; public String name; public StuNode next; public StuNode(int no, String name) { this.no = no; this.name = name; } public StuNode(){ } @
图解链表 —— JAVA中的单链表基本操作
AlinaQ05的博客
05-17 2123
文章目录1. 什么是链表2. 链表的种类3. 创建单链表3.1 创建 Node 类（车厢类）3.2 创建 MySingleList (火车类）4. 单链表的基本操作4.1 增加链表元素4.1.1 在链表头部添加元素4.1.2 在链表任意位置添加元素4.1.3 在链表尾部添加元素4.2 删除链表元素4.2.1 删除第一个节点元素4.2.2 删除任意位置 index 元素4.2.3 删除链表中指定元素的第一个节点4.2.4 删除链表的所有指定元素4.3 查找链表元素4.3.1 判断链表中是否包含元素 data4
Java之单列集合
y_k_j_c的博客
07-21 835
所有实现了Collection接口的集合类，都有一个iterator()方法可以返回一个实现了Iterator的对象，即迭代器Iterator用于遍历集合，本身不存放对象。
Java链表总结
m0_56987404的博客
05-04 1314
链表简单的curd操作入门
Java实现单链表（步骤详解+源码）
GSCY
10-14 6550
Java实现单链表（步骤详解+源码） 欢迎大家提出问题，一起学习！
Java实现单链表的基本操作
qq_51560486的博客
08-21 1026
使用Java语言实现单链表的基本操作，包括对单链表的指定节点插入数据、删除指定位置节点的数据、修改指定节点的数据，查询数据；以及单链表的反转和倒数第k个节点的输出。线性表的链式存储结构：n个结点链结成一个链表，即为线性表的链式存储结构，由于每一个结点只包含一个指针域，因此称为单链表。链表中第一个结点的存储位置成为头指针，那么整个链表的存取就必须是从头指针开始了。有时候会在单链表的第一个结点前附设一个结点，称为头结点。
Java List单例表: Collections::singletonList VS List::of
沛哥儿的专栏
04-27 1388
在Java中，怎样将一个类型T的单个对象，转换为一单例的List<T>？ 一种最简单的方法，创建并实例化为一个ArraList或者LinkedList的对象。然后把它Add进去。 但是，你会发现这种做法缺少了编码的乐趣，让人感觉没有追求。像我们这种有悟性的研发，就应该想着怎么用一行代码来搞定它。好消息是JavaSE提供了多个一行代码来解决这个问题的方法。 在这里，我们不讨论那种匿名函数的双括号的实现方式。因为看起来是使用了一行代码来创建和添加单个对象。但是它实际上是两行代码：一行来实例化List的子类
迪杰斯特拉算法——最短路径算法python
10-27
迪杰斯特拉算法是一种解决有向图中最短路径问题的算法。下面是使用Python实现迪杰斯特拉算法的步骤： 1. 创建一个空的字典dist，用于存储每个顶点到源点的距离，初始值为无穷大。 2. 将源点的距离设置为0，并将源点加入到一个集合visited中。 3. 对于源点的每个邻居，更新其距离为源点到该邻居的距离，并将其加入到一个优先队列中。 4. 从优先队列中取出距离最小的顶点，将其加入到visited集合中，并更新其邻居的距离。 5. 重复步骤4，直到所有顶点都被加入到visited集合中。 下面是一个使用Python实现迪杰斯特拉算法的例子： ```python import heapq def dijkstra(graph, start): dist = {v: float('inf') for v in graph} dist[start] = 0 visited = set() pq = [(0, start)] while pq: (d, u) = heapq.heappop(pq) if u in visited: continue visited.add(u) for v, w in graph[u].items(): if dist[v] > dist[u] + w: dist[v] = dist[u] + w heapq.heappush(pq, (dist[v], v)) return dist ``` 其中，graph是一个字典，表示有向图的邻接表。例如，如果有一条从顶点A到顶点B的边权为3的边，则graph[A][B] = 3。start是源点的名称。函数返回一个字典，表示每个顶点到源点的最短距离。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值