数据结构与算法--使用Java实现单链的LinkedList

最新推荐文章于 2021-10-22 18:15:28 发布
最新推荐文章于 2021-10-22 18:15:28 发布
阅读量685 收藏 3
点赞数
分类专栏： 数据结构与算法 Java 文章标签： java 链表 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40861707/article/details/105078719
版权

上一篇博客中,使用Java实现了ArrayList的基本功能,博客链接如下:

数据结构与算法–使用Java实现ArrayList

今天继续实现另一种数据结构:LinkedList
循序渐进,先用单链表实现~

本篇博客所涉及到的代码,均已上传到github:
项目github链接
本篇博客涉及代码github链接

本篇博客要点如下:

链表简介

使用Java代码实现单链的LinkedList

全量代码分享

一. 链表简介

LinkedList是和ArrayList一样重要的一种数据结构
我们常说:
LinkedList的底层数据结构是链表,查询慢,增删快,线程不安全,效率高
如果我们想要知道,它为什么具有这样的特性,就需要对链表这种数据结构有一个进一步的了解

链表概念

链表是一种物理存储单元上非连续、非顺序的存储结构，
数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。
每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。

链表存储结构

因为本篇博文是以单链表实现LinkedList,因此这里以单链表进行举例:
我们从图片中,我们可以看到:

和数组的元素值存储数据不同,
对于链表中的每一个元素, 包含了存储元素的数据域,和存储下一个元素地址的指针域.
最后一个元素的指针域为空
同时,链表中逻辑上连续的元素,在物理存储结构又是不连续的,这一点也和数组不同

那么这种存储结构具有什么优点和缺点呢?

优点:
1.增删性能高
在新增数据时,只要将前驱节点的指针域指向新增的元素,将新增元素的指针域指向后继节点即可
在删除数据时,只要将删除元素前驱节点的指针域指向删除元素后继节点的指针域即可
(但这种性能高并不适用于所有的链表哦,请大家结合下面我写的单链的增删代码来判断一下单链是否具有这个优点)
所以,链表进行增删操作的时间复杂度T(n)=O(1).
而数组是O(n)

2.不存在闲置的情况
每一个节点,都包含了一个数据域和指向下一个元素地址的指针域,没有闲置.
从这个角度来说,节约内存资源

缺点:

1.操作难度大,理解成本高
姑且把这个算作为链表的一个缺点
对于我这种不够聪明的人来说,学习链表的成本确实高于数组!

2.查询效率低
链表的查询,只能从头结点开始遍历,根据指针域一个一个获取元素,
查询操作的时间复杂度为T(n)=O(n)

3.除了数值域,还要为指针域分配额外的空间

二.使用Java代码实现LinkedList

基于上述的了解: 我们可以开始试着手写一个简单的LinkedList
使用Java的人应该都知道,LinkedList和ArrayList一样,都实现了List接口
因此,ArrayList集合的操作,同样适用于LinkedList,只是实现方式有所差异.

集合大小,非空判断,增加元素,删除元素,修改元素,获取元素,字符串转换

我们把上面列举出来的每一种操作封装为一个方法,可以得到一个接口,如下:

List接口
public interface List {
    // 返回线性表的大小,即数据元素的个数
    int size();
    // 返回线性表序号为i的数据元素
    Object get(int i);
    // 判断线性表是否包含数据元素e
    boolean contains(Object e);
    // 线性表为空返回true,否则返回false
    boolean isEmpty();
    // 返回数据元素e在线性表中的序号
    int indexOf(Object e);
    // 将数据元素e插入到线性表中的i号位置
    void add(int i, Object e);
    // 将元素e插入到线性表末尾
    void add(Object e);
    // 将元素e插入到元素obj之前
    boolean addBefore(Object obj, Object e);
    // 将元素e插到元素obj之后
    boolean addAfter(Object obj, Object e);
    // 删除线性表中序号为i的元素,并返回
    Object remove(int i);
    // 删除线性表中第一个与a相同的元素
    boolean remove(Object e);
    // 替换线性表中序号为i的数据元素为e,返回原数据元素
    Object replace(int i, Object e);
}
Node类的引入

链表中的每个元素, 包含一个数据域和一个指针域
为了更形象的描述链表结构,我们把它抽象成一个实体类Node
用Object类型的数据data来表示数据域
用Node类型的数据next来表示链表的指针域

如下面的代码所示:


/**
 * @author xmr
 * @description 单链表 只能通过前驱节点找到后继节点,不能通过后继节点找到前驱节点
 */
public class Node {

    Object data; // 要存储的数据
    Node next; // 指向下一个节点的指针

    public Node(Object data) {
        super();
        this.data = data;
    }

    public Node(Object data, Node next) {
        super();
        this.data = data;
        this.next = next;
    }

    public Node() {

    }


    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }
}
实现单链的LinkedList

我们需要两个成员变量来表示
LinkedList的头结点和大小

  private Node head = new Node(); // 头结点,不存储数据,为了编码方便,以方便对空链表和只有一个节点的链表进行处理
    private int size; // 单链表的节点个数
获取集合大小

成员变量size表示集合大小,返回它即可

  @Override
    public int size() {
        return size;
    }
获取集合元素

获取集合指定索引元素的数据域

    @Override
    public Object get(int i) {
    	// 首先要进行参数检查
        if (i < 0 || i >= size) {
            throw new RuntimeException("指针越界! " + i);
        }
        // 因为链表只能通过前驱节点的指针去寻找后继节点,所以链表的查询需要从头开始遍历
        Node p = head;
       for (int j = 0; j <= i; j++) {
           p = p.next;
       }
       return p.data;
    }

从代码中我们可以看到,链表查询的性能并不高,时间复杂度:T(n)=O(n)

获取指定元素第一次出现的索引

    @Override
    public int indexOf(Object e) {
        Node p = head.next; // 这里p指的是链表的真正意义上的第一个元素,因为头结点的数据域永远为Null
      for (int i = 0; i < size; i++) {
      	  // 首先针对空值进行判断,以免出现空指针异常
          if (e == null) {
              if (p.data == null) {
                  return i;
              }
          } else {
              if (e.equals(p.data)) {
                  return i;
              }
          }
          p = p.next;
      }
      // 在链表中找不到对应的元素,返回-1
      return -1;
    }
判断集合是否包含指定元素
   @Override
    public boolean contains(Object e) {
      // 这里我最初是采用遍历的方法进行判别的,后面想到,我在之前实现的indexOf方法
      // 试想,若集合包含某个元素,则该元素在集合里对应的索引应该大于等于0
      // 所以,我们在这里复用上面的indexOf方法,实现如下:
      return indexOf(e) >= 0;
    }
判断集合是否为空
@Override
    public boolean isEmpty() {
    	// 集合为空,代表集合大小为0
        return size == 0;
    }
集合数据添加

添加元素有以下情况:一种是添加到集合指定索引位置,一种是添加到集合的最后
一种是添加到指定元素的前面,一种是添加到指定元素的后面

	/*
		添加元素到指定位置
		思路:1. 找到要插入元素的前驱节点
			2. 将前驱节点的指针指向该元素
			3. 将该元素的指针指向后继节点
	*/
    @Override
    public void add(int i, Object e) {
        if (i >  size || i < 0) {
            throw new RuntimeException("指针越界! " + i);
        }
        // 找到前一个节点,从head节点开始
        Node p = head;
        for (int j = 0; j < i; j++) {
            p = p.next;
        }
        // 新创建一个节点
        Node newNode = new Node(e);
        newNode.data = e; //新节点的数据域为要插入元素e
        newNode.next = p.next;
        // 指明新节点的直接后继节点
        // 指明新节点的直接前驱节点
        p.next = newNode;
        size ++; // 添加完元素,链表的大小也要做出相应改变
    }


/*
	这里我们考虑到,插入到链表末尾,只是插入到指定位置的一种特殊情况
	因此,直接调用上面的方法即可
*/
@Override
    public void add(Object e) {
        this.add(size, e);
    }

	/*
		添加到指定元素的前面,若链表里没有该元素,返回false
	*/
 	@Override
    public boolean addBefore(Object obj, Object e) {
       // 首先寻找到该元素,找不到就返回false
        int index = indexOf(e);
        if (index < 0) {
            return false;
        }
        // 找到该元素的前一个节点
        Node p = head;
        for (int i = 0; i < index; i++) {
            p = p.next;
        }
        Node node = new Node(obj);
        // 修改e前一个节点的指针,使其指向obj
        node.data = obj;
        node.next = p.next;
        // 让obj的指针指向e的后继节点
        p.next = node;
        size++;
        return true;
    }


	/*
		添加到指定元素的后面,若链表里没有该元素,返回false
	*/
    @Override
    public boolean addAfter(Object obj, Object e) {
        // 首先寻找到该元素,找不到就返回false
        int index = indexOf(e);
        if (index < 0) {
            return false;
        }
        // 找到该元素的后一个节点
        Node p = head.next;
        for (int i = 0; i < index; i++) {
            p = p.next;
        }
        Node node = new Node(obj);
        // 修改e前一个节点的指针,使其指向obj
        node.data = obj;
        node.next = p.next;
        // 让obj的指针指向e的后继节点
        p.next = node;
        size++;
        return true;
    }
集合数据删除
	/*
		删除集合对应索引的元素,返回旧值
		删除操作的关键点 : 将要删除元素的前驱节点的指针直接指向要删除元素的后继节点
	*/
	@Override
    public Object remove(int i) {
        if (i >= size || i < 0) {
            throw new RuntimeException("指针越界! " + i);
        }
        Node p = head;
        // 找到索引i的前一个元素
        for (int j = 0 ; j < i; j++) {
            p = p.next;
        }
        Node node = p.next; // 索引i所在位置的元素
        // 将前一个元素的指针指向 索引i的后一个元素
        p.next = p.next.next;
        System.out.println(node);
        size --;
        return node;
    }

     /*
        删除集合里指定的元素
        思路: 我们可以找到该元素在链表中对应的索引
        然后把它转换成通过索引进行删除的方式
     */
    @Override
    public boolean remove(Object e) {
        int i = indexOf(e);
        if (i < 0 || i >= size) {
            return false;
        }
        remove(i);
        return true;
    }
集合数据替换
    /*
        将集合指定索引的元素替换为特定的值,并返回原数据元素
        思路:集合元素的替换不需要考虑指针,
        找到对应索引对应的元素,直接替换data域即可
    */
    @Override
    public Object replace(int i, Object e) {
        if (i < 0 || i >= size) {
            throw new RuntimeException("指针越界! " + i);
        }
        Node p = head;
        for (int j = 0; j < i; j++) {
            p = p.next;
        }

        // 将前一个元素的值替换为e
        Node oldValue = p.next;
        p.next.data = e;
        return oldValue;
    }
重写toString()方法
    /*
    	对我来说,重写该方法的目的就是使输出变得更友好,
    	方便进行代码调试.如下:输出为[data1,data2]这种格式
    */
	@Override
    public String toString() {
        if (size == 0) {
            return "[]";
        }
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        Node p = head.next;
        for (int i = 0; i < size; i++) {
            if (i != size - 1) {
                sb.append(p.data).append(",");
            } else {
                sb.append(p.data);
            }
            p = p.next;
        }
        sb.append("]");
        return sb.toString();
    }

如上,我们通过自己的方式实现了LinkedList的基本功能!

三. 全量代码分享

/**
 * @author xmr
 * @description 使用java语言实现单链表的基本功能
 */
public class SingleLinkedList implements List{
    private Node head = new Node(); // 头结点,不存储数据,为了编码方便,以方便对空链表和只有一个节点的链表进行处理
    private int size; // 单链表的节点个数

    public static void main(String[] args) {
        List list = new SingleLinkedList();
        list.add(0, "32");
        list.add(1, null);
        list.addBefore("64", "32");
        // list.remove(2);
        list.replace(1, "18");
        System.out.println(list.get(0));
        System.out.println(list.size());
        System.out.println(list.toString());
        System.out.println(list.indexOf(null));
    }
    @Override
    public int size() {
        return size;
    }

    @Override
    public Object get(int i) {
        if (i < 0 || i >= size) {
            throw new RuntimeException("指针越界! " + i);
        }
        Node p = head;
       for (int j = 0; j <= i; j++) {
           p = p.next;
       }
       return p.data;
    }

    @Override
    public boolean contains(Object e) {
        return indexOf(e) >= 0;
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public int indexOf(Object e) {
        Node p = head.next;
      for (int i = 0; i < size; i++) {
          if (e == null) {
              if (p.data == null) {
                  return i;
              }
          } else {
              if (e.equals(p.data)) {
                  return i;
              }
          }
          p = p.next;
      }
      return -1;
    }

    @Override
    public void add(int i, Object e) {
        if (i >  size) {
            throw new RuntimeException("指针越界! " + i);
        }
        // 找到前一个节点,从head节点开始
        Node p = head;
        for (int j = 0; j < i; j++) {
            p = p.next;
        }
        // 新创建一个节点
        Node newNode = new Node(e);
        newNode.data = e;
        newNode.next = p.next;
        // 指明新节点的直接后继节点
        // 指明新节点的直接前驱节点
        p.next = newNode;
        size ++;
    }

    @Override
    public void add(Object e) {
        this.add(size, e);
    }

    @Override
    public boolean addBefore(Object obj, Object e) {
       // 首先寻找到该元素,找不到就返回false
        int index = indexOf(e);
        if (index < 0) {
            return false;
        }
        // 找到该元素的前一个节点
        Node p = head;
        for (int i = 0; i < index; i++) {
            p = p.next;
        }
        Node node = new Node(obj);
        // 修改e前一个节点的指针,使其指向obj
        node.data = obj;
        node.next = p.next;
        // 让obj的指针指向e的后继节点
        p.next = node;
        size++;
        return true;
    }

    @Override
    public boolean addAfter(Object obj, Object e) {
        // 首先寻找到该元素,找不到就返回false
        int index = indexOf(e);
        if (index < 0) {
            return false;
        }
        // 找到该元素的后一个节点
        Node p = head.next;
        for (int i = 0; i < index; i++) {
            p = p.next;
        }
        Node node = new Node(obj);
        // 修改e前一个节点的指针,使其指向obj
        node.data = obj;
        node.next = p.next;
        // 让obj的指针指向e的后继节点
        p.next = node;
        size++;
        return true;
    }

    @Override
    public Object remove(int i) {
        if (i >= size || i < 0) {
            throw new RuntimeException("指针越界! " + i);
        }
        Node p = head;
        // 找到索引i的前一个元素
        for (int j = 0 ; j < i; j++) {
            p = p.next;
        }
        Node node = p.next; // 索引i所在位置的元素
        System.out.println(node.data);
        // 将前一个元素的指针指向 索引i的后一个元素
        p.next = p.next.next;
        System.out.println(node);
        size --;
        return node;
    }

    @Override
    public boolean remove(Object e) {
        int i = indexOf(e);
        if (i < 0 || i >= size) {
            return false;
        }
        remove(i);
        return true;
    }

    @Override
    public Object replace(int i, Object e) {
        if (i < 0 || i >= size) {
            throw new RuntimeException("指针越界! " + i);
        }
        Node p = head;
        for (int j = 0; j < i; j++) {
            p = p.next;
        }

        // 将前一个元素的指针指向node
        Node oldValue = p.next;
        p.next.data = e;
        return oldValue;
    }
    /*
        单链表 :
        数据, 指向后面节点的指针
     */

    @Override
    public String toString() {
        if (size == 0) {
            return "[]";
        }
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        Node p = head.next;
        for (int i = 0; i < size; i++) {
            if (i != size - 1) {
                sb.append(p.data).append(",");
            } else {
                sb.append(p.data);
            }
            p = p.next;
        }
        sb.append("]");
        return sb.toString();
    }
}

后记: 有的时候真的是眼高手低,看起来很简单的东西
自己实践起来,却是漏洞百出,调试的心累~
总之,基础还不够扎实,动手能力也不够强

还是得多练习,多学习!!!

new个对象先
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java数据结构与算法-线性表（详细实现）
qq_41649001的博客
07-25 3354
线性表（Linear List） 2.1 什么是线性表 零个或多个数据元素的有限序列。 非空线性表的逻辑结构特征 有且仅有一个开始结点，无直接前趋，有且只有一个直接后继 有且仅有一个结束结点，有且只有一个直接前趋，无直接前驱。 内部结点都有且只有一个直接前趋和一个直接后继 对于同一线性表，数据类型一直，数据元素长度一致。 2.2 线性表基本运算 基本运算包括 initList 初始化操作，建立一个空的线性表 listEmpty 若线性表为空，返回true，否则返回false
Java数据结构与算法之LinkedList单链表
Andy_lau
10-02 3634
目录： 1.链表概述 2.链表分类即结构 3.单链表 3.1 自定义单链表需要实现的功能(方法) 3.2 单链表实现代码 1.链表概述： 链表具有逻辑连续，物理存储不连续且大小不固定的特点，它是基于指针实现的。其中单链表和单向循环链表中的每一个节点包含了一 个数据域和一个指针域，数据域保存节点的数据，指针域保存节点的下一个节点位置，当需要查找当前节点的下一个节点时，即可通过
LinkedList：在Java中使用链表-带有在任何位置插入，删除，检查长度和查找特定节点的方法
02-24
LinkedList：在Java中使用链表-带有在任何位置插入，删除，检查长度和查找特定节点的方法
java实现链表模拟LinkedList类
weixin_30919235的博客
07-06 91
LinkedList类底层数据结构 模拟： 1 package Collection; 2 3 public class MyLinkedList { 4 Node first; 5 Node last; 6 private int size; 7 public MyLinkedList(){ 8 ...
java链表程序_Java 程序实现链表(LinkedList)数据结构
weixin_36200490的博客
02-17 341
Java 程序实现链表(LinkedList)数据结构在这个实例中，我们将学习用Java实现链表数据结构。要了解此示例，请确保您首先访问以下教程，示例1：实现LinkedList的Java程序示例classLinkedList{//创建Node类的对象//表示链表的头部Nodehead;//静态内部类staticclassNode{intvalue;//将每个节点连接到下一个节点No...
JAVA学习-数据结构-LinkedList
阿斯蒂芬的博客
07-02 174
ArrayList 和 LinkedList都是List的实现类。ArrayList是通过维护一个数组实现，而LinkedList是通过维护链表实现的。 代码如下： （两个结构的方法差不多，不过有些方法的复杂度不同，取决于他们的内部数据结构） private ListNode headNode; private ListNode tailNode; private int ...
prim算法用邻接链表和堆实现
weixin_41677899的博客
12-12 770
将V分为两个顶点集，一个Vt包含进入生成树的节点，一个V-Vt为剩下的节点。 每次选的边的两个顶点要分别落在Vt和V-Vt里面，选满足要求最小的边。 这个做法是用最小堆来选择，最小堆里存的是顶点，排序依据是当前生成树到各顶点最短边的权值（可以存下来）。 由于堆中元素是|V|-1个,取出一个是log |V|， 另外每次取出一个顶点加入生成树，都要比较一下与该顶点相连的那些顶点，如果存的顶点权值发生改...
Data-Structures---Algorithms:使用Java的数据结构和算法
03-20
数据结构与算法是计算机科学的基础，对于任何编程语言来说，理解和掌握它们都是至关重要的，特别是对于Java这种广泛应用的编程语言。本资源“Data-Structures---Algorithms:使用Java的数据结构和算法”聚焦于如何在...
数据结构与算法基础（java版）.zip
07-10
在这个Java版的数据结构与算法课程中，我们将深入探讨以下几个核心概念： 1. **单链表**：单链表是一种线性数据结构，其中每个元素（节点）包含数据以及指向下一个节点的引用。通过Java编程，你可以学习如何创建、...
链表(LinkedList)---单链表
小梁
04-20 206
文章目录1. 动态数组的缺点2. 链表      2.1 链表 1. 动态数组的缺点 每次申请指定大小的空间,造成内存空间的大量浪费 能否用到多少就申请使用多少呢？链表 2. 链表       2.1 链表 ...
java单链集合_java 单链集合实现
weixin_29335033的博客
02-27 209
本文参考LinkedList源码实现单链集合的实现，如果想了解双链实现，请参考点击打开链接接口：public interface MyList {/*** 定义添加接口* @param element*/public void add(T element);/*** 定义clear接口*/public void clear();/*** 删除接口* @param index* @return*/p...
java读源码 之 list源码分析（LinkedList）
做一个认真的程序员
06-28 264
文章目录LinkedList:继承关系分析：字段分析：构造函数分析：方法分析： LinkedList: 继承关系分析： public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, java.i...
单链
TRHYKJDH的博客
07-25 704
尾插 import java.util.Random; import java.util.Scanner; public class Link { //创建一个存储数据的属性 int data; //创建存储下一个节点地址的属性 Link next; static int length=0; ...
Java程序-单链表增删改查（实现对水浒人物的增删改查操作）
不知谓
08-02 445
文章目录前言一、链表（Linked List）介绍二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、链表（Linked List）介绍 二、使用步骤 1.引入库 代码如下（示例）： import numpy as np import pandas as pd import matplotlib
[源码分析]ArrayList和LinkedList如何实现的？我看你还有机会！
未读代码
08-13 249
文章已经收录在 Github.com/niumoo/JavaNotes ，更有 Java 程序员所需要掌握的核心知识，欢迎Star和指教。 欢迎关注我的公众号，文章每周更新。 前言 说真的，在 Java 使用最多的集合类中，List 绝对占有一席之地的，它和 Map 一样适用于很多场景，非常方便我们的日常开发，毕竟存储一个列表的需求随处可见。尽管如此，还是有很多同学没有弄明白 List 中 ArrayList 和 LinkedList 有什么区别，这简直太遗憾了，这两者其实都是数据结构中的基础内容，这篇.
为什么数组查询快，链表增删快
weixin_58276266的博客
10-22 1571
1、它是具有相同数据型的数据，并且有一定的顺序，数组在内存中的地址是连续相邻的。而链表在内存中是散列存放的。 2、数组的中间插入（或删除）一个元素，那么这个元素后的所有元素的内存地址都要往后（前）移动（数组的内存地址是连续的），对最后一个元素插入（或删除）时才比较快，而链表不需要改变内存的地址，只需要修改节点的信息即可（包括指针指向，节点值）。 ...
C/C++,java 数据结构---线性链表存储数据:获取数据慢，增删快
xielinhua88的博客
05-19 697
LinkList.h#ifndef _LINK_LIST #define _LINK_LIST typedef void LinkList; typedef struct _linklist { struct _linklist* next; }LinkListNode; LinkList* create(); int insert(LinkList* list,LinkListNode*
java：手写MyLinkedList所有方法，增删改查
qiaolevip的专栏
05-17 1605
package arrays.myArray;public class MyLinkedList { private int size = 0; private Node1 head = null; // 添加 public void add(Object obj) {  add(size, obj); } // 修改 public void add(int index, Object
Java数据结构与算法详解：从数组到红-黑树
"Java数据结构和算法，涵盖了数组、简单排序、栈与队列、链表、递归、哈希表、高级排序、二叉树、红-黑树、堆以及带权图等核心概念。" 在Java编程中，理解和掌握数据结构与算法是至关重要的，因为它们构成了程序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值