数据结构 - 2（ 顺序表 9000 字详解 ）

已于 2024-07-20 22:37:17 修改
阅读量1.3k 收藏 15
点赞数 15
分类专栏： 数据结构 文章标签： 数据结构
于 2023-10-13 19:30:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_73232539/article/details/133814920
版权

一：List

1.1 什么是List

在集合框架中，List 是一个接口，继承自 Collection。
在这里插入图片描述
Iterable 是一个接口，Iterable 接口表示实现该接口的类是可以逐个元素进行遍历的，Collection 也是一个接口，该接口中规范了后序容器中常用的一些方法，具体如下所示：
在这里插入图片描述

站在数据结构的角度来看，List 就是一个线性表，即 n 个具有相同类型元素的有限序列，在该序列上可以执行增删改查以及变量等操作。

List 中常用的方法如下所示：

方法解释
boolean add(E e)尾插 e
void add(int index, E element)将 e 插入到 index 位置
boolean addAll(Collection<? extends E> c)尾插 c 中的元素
E remove(int index）删除 index 位置元素
boolean remove(Object o)删除遇到的第一个 o
E get(int index)获取下标 index 位置元素
E set(int index, E element ）将下标 index 位置元素设置为 element
void clear()清空
boolean contains(Object o）判断 o 是否在线性表中
int indexOf(Object o)返回第一个 o 所在下标
int lastIndexOf(Object o)返回最后一个 o 的下标
List < E> subList(int fromIndex, int toIndex)截取部分 list

1.2 List 的使用

注意：List 是个接口，并不能直接用来实例化，如果要使用，必须去实例化 List 的实现类。在集合框架中，ArrayList 和 LinkedList 都实现了List接口。

使用实例如下：

List<String> arrayList = new ArrayList<>(); // 使用ArrayList实现
List<Integer> linkedList = new LinkedList<>(); // 使用LinkedList实现

//添加元素
arrayList.add("Apple");
arrayList.add("Banana");
arrayList.add("Orange");

//添加元素
linkedList.add(10);
linkedList.add(20);
linkedList.add(30);

我们通过向上转型，分别调用了 ArrayList 和 LinkedList 中的 add 重写方法，这两个方法在 ArrayList 和 LinkedList 中都有自己的实现方式

二： ArrayList 的使用

2.1 什么是线性表

线性表（linear list）是 n 个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列…

线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。

比如说：
在这里插入图片描述
顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。

2.2 ArrayList 简介

在这里插入图片描述
【说明】

  1. ArrayList 是以泛型方式实现的，使用要指定一下泛型参数
  2. ArrayList 实现了 RandomAccess 接口，表明 ArrayList 支持随机访问
  3. ArrayList 实现了 Cloneable 接口，表明 ArrayList 是可以 clone 的
  4. ArrayList 实现了 Serializable 接口，表明 ArrayList 是支持序列化的
  5. 和 Vector不同，ArrayList 不是线程安全的，在单线程下可以使用，在多线程中可以选择 Vector 或者 CopyOnWriteArrayList
  6. ArrayList 底层是一段连续的空间，并且可以动态扩容，是一个动态类型的顺序表

2.3 ArrayList的使用

方法解释
ArrayList()无参构造
ArrayList(Collection<? extends E> c)利用其他 Collection 构建 ArrayList
ArrayList(int initialCapacity)指定顺序表初始容量

ArrayList(Collection<? extends E> c) 是一个构造函数，它接受一个实现了 Collection 接口的对象 c。这个构造函数会将 c 中的所有元素添加到新创建的 ArrayList 中。

通常情况下，ArrayList 是按照元素的添加顺序来存储的，而 ArrayList(Collection<? extends E> c) 可以方便地将另一个集合的元素全部添加到当前的 ArrayList 中。

例如，假设有一个 List 对象 list，可以使用如下代码创建一个新的 ArrayList，并将 list 中的所有元素添加到新的 ArrayList 中：

ArrayList<String> arrayList = new ArrayList<>(list);

在上述代码中，ArrayList<String> arrayList 是一个新创建的 ArrayList 对象，它包含了 list 中的所有元素。

2.4 ArrayList 的常用方法

方法解释
boolean add(E e)尾插 e
void add(int index, E element)将 e 插入到 index 位置
boolean addAll(Collection<? extends E> c)尾插 c 中的元素
E remove(int index)删除 index 位置元素
boolean remove(Object o)删除遇到的第一个 o
E get(int index)获取下标 index 位置元素
E set(int index, E element)将下标 index 位置元素设置为element
void clear()清空
boolean contains(Object o)判断 o 是否在线性表中
int indexOf(Object o)返回第一个 o 所在下标
int lastIndexOf(Object o)返回最后一个 o 的下标
List< E > subList(int fromIndex, int toIndex)截取部分 list

方法使用实例：

public static void main(String[] args) {
  List<String> list = new ArrayList<>();
  list.add("JavaSE");                   //  [JavaSE]
  list.add("JavaWeb");                  //  [JavaSE, JavaWeb]
  list.add("JavaEE");                   //  [JavaSE, JavaWeb, JavaEE]
  list.add("JVM");                      //  [JavaSE, JavaWeb, JavaEE, JVM]
  list.add("测试课程");                 //  [JavaSE, JavaWeb, JavaEE, JVM, 测试课程]
  System.out.println(list);
 
  System.out.println(list.size());      // 输出结果: 5
 
  System.out.println(list.get(1));      // 输出结果: JavaWeb
  list.set(1, "JavaWEB");                // [JavaSE, JavaWEB, JavaEE, JVM, 测试课程]
  System.out.println(list.get(1));
 
  list.add(1, "Java数据结构");              //  [JavaSE, Java数据结构, JavaWEB, JavaEE, JVM, 测试课程]
  System.out.println(list);
  
  list.remove("JVM");                    // 输出结果: [JavaSE, Java数据结构, JavaWEB, JavaEE, 测试课程]
  System.out.println(list);
  
  list.remove(list.size()-1);            // 输出结果: [JavaSE, Java数据结构, JavaWEB, JavaEE]
  System.out.println(list);
  
  if(list.contains("测试课程")){          
    list.add("测试课程");					 //  [JavaSE, Java数据结构, JavaWEB, JavaEE, 测试课程]
  }
 
  System.out.println(list.indexOf("JavaSE"));   // 输出结果: 0
  System.out.println(list.lastIndexOf("JavaSE"));   // 输出结果: 0
 
  List<String> ret = list.subList(0, 4);     //  [JavaSE, Java数据结构, JavaWEB, JavaEE]
  System.out.println(ret);
 
  list.clear();
  System.out.println(list.size());          // 输出结果: 0
}

2.5 ArrayList 的遍历

ArrayList 可以使用三种方式遍历：for 循环、foreach、使用迭代器

public static void main(String[] args) {
  List<Integer> list = new ArrayList<>();
  list.add(1);
  list.add(2);
  list.add(3);
  list.add(4);
  list.add(5);
  
  // 使用下标+for遍历
  for (int i = 0; i < list.size(); i++) {
    System.out.print(list.get(i) + " ");
 }
  System.out.println();
  
  // 借助foreach遍历
  for (Integer integer : list) {
    System.out.print(integer + " ");
 }
  System.out.println();

  //迭代器遍历
  Iterator<Integer> it = list.listIterator();
  while(it.hasNext()){
    System.out.print(it.next() + " ");
 }
  System.out.println();
}

注意：迭代器是一次性的，即只能从头到尾进行一次遍历。如果需要重新遍历集合，你需要重新创建一个新的迭代器。

2.6 ArrayList 的扩容机制

ArrayList 是一个动态类型的顺序表，当我们向 Java 的 ArrayList 中添加元素时，ArrayList 会自动扩容，以容纳更多的元素。ArrayList 的扩容机制如下：

  1. 初始容量：每个 ArrayList 对象都有一个初始容量。在创建 ArrayList 对象时，如果没有指定初始容量大小，则默认为10。

  2. 扩容策略：当 ArrayList 的操作次数达到其内部数组长度时，就会触发扩容操作。ArrayList 的默认扩容因子是 1.5 倍，即每次扩容后的容量为当前容量的 1.5 倍。

  3. 数组拷贝：扩容时，ArrayList 会创建一个新的数组，将原有元素拷贝到新数组中。这个过程涉及到数组的创建和数据的拷贝，所以在扩容操作时可能会对性能产生一定的影响。

扩容是一个相对耗时的操作，因为它涉及到数据的拷贝和存储空间的重新分配。因此，在知道需要存储大量元素的情况下，为 ArrayList 显式指定一个初始容量，可以减少扩容操作的次数，提高性能。

三：模拟实现一个 ArrayList

3.1 方法框架

public class SeqList {
  private int[] array;
  private int size;
  
  // 默认构造方法
  SeqList(){  }
  
  // 将顺序表的底层容量设置为initcapacity
  SeqList(int initcapacity){  }
  
  // 新增元素,默认在数组最后新增
  public void add(int data) { }
  
  // 在 pos 位置新增元素
  public void add(int pos, int data) { }
  
  // 判定是否包含某个元素
  public boolean contains(int toFind) { return true; }
  
  // 查找某个元素对应的位置
  public int indexOf(int toFind) { return -1; }
  
  // 获取 pos 位置的元素
  public int get(int pos) { return -1; }
  
  // 给 pos 位置的元素设为 value
  public void set(int pos, int value) {  }
  
  //删除第一次出现的关键字key
  public void remove(int toRemove) {  }
  
  // 获取顺序表长度
  public int size() { return 0; }
  
  // 清空顺序表
  public void clear() {  }
 
  // 打印顺序表，注意：该方法并不是顺序表中的方法，为了方便看测试结果给出的
  public void display() {  }
}

3.2 模拟实现 ArrayList

 class MyArrayList {
  private int[] array;
  private int size;//记录当前元素个数

  // 默认构造方法
  public MyArrayList() {
    // 初始化底层数组，初始容量为10
    array = new int[10];
    // 初始大小为0
    size = 0;
  }

  // 将顺序表的底层容量设置为initCapacity
  public MyArrayList(int initCapacity) {
    if (initCapacity < 0) {
      throw new IllegalArgumentException("容量不能小于0");
    }
    // 初始化底层数组，初始容量为initCapacity
    array = new int[initCapacity];
    // 初始大小为0
    size = 0;
  }

  // 在数组最后新增元素
  public void add(int data) {
    // 如果数组已满，则扩容
    if (size == array.length) {
      resize();
    }
    // 在数组末尾新增元素
    array[size] = data;
    // 更新大小
    size++;
  }

  // 在指定位置新增元素
  public void add(int pos, int data) {
    // 检查位置是否合法
    if (pos < 0 || pos > size) {
      throw new IndexOutOfBoundsException("索引超出范围");
    }
    // 如果数组已满，则扩容
    if (size == array.length) {
      resize();
    }
    // 将指定位置及其后面的元素后移一位
    for (int i = size - 1; i >= pos; i--) {
      array[i + 1] = array[i];
    }
    // 在指定位置插入元素
    array[pos] = data;
    // 更新大小
    size++;
  }

  // 判定是否包含某个元素
  public boolean contains(int toFind) {
    // 遍历数组查找元素
    for (int i = 0; i < size; i++) {
      if (array[i] == toFind) {
        return true;
      }
    }
    return false;
  }

  // 查找某个元素对应的位置
  public int indexOf(int toFind) {
    // 遍历数组查找元素
    for (int i = 0; i < size; i++) {
      if (array[i] == toFind) {
        return i;
      }
    }
    // 未找到元素，返回-1
    return -1;
  }

  // 获取指定位置的元素
  public int get(int pos) {
    // 检查位置是否合法
    if (pos < 0 || pos >= size) {
      throw new IndexOutOfBoundsException("索引超出范围");
    }
    // 返回指定位置的元素
    return array[pos];
  }

  // 设置指定位置的元素
  public void set(int pos, int value) {
    // 检查位置是否合法
    if (pos < 0 || pos >= size) {
      throw new IndexOutOfBoundsException("索引超出范围");
    }
    // 更新指定位置的元素
    array[pos] = value;
  }

  // 删除第一次出现的指定元素
  public void remove(int toRemove) {
    // 遍历数组查找要删除的元素
    for (int i = 0; i < size; i++) {
      if (array[i] == toRemove) {
        // 将要删除元素后面的元素前移一位
        for (int j = i + 1; j < size; j++) {
          array[j - 1] = array[j];
        }
        // 更新大小
        size--;
        return;
      }
    }
  }

  // 获取顺序表长度
  public int size() {
    return size;
  }

  // 清空顺序表
  public void clear() {
    // 将数组清空
    for (int i = 0; i < size; i++) {
      array[i] = 0;
    }
    // 大小置为0
    size = 0;
  }

  // 扩容数组
  private void resize() {
    // 创建新的数组，长度为当前容量的两倍
    int[] newArray = new int[array.length * 2];
    // 将原数组中的元素复制到新数组中
    for (int i = 0; i < size; i++) {
      newArray[i] = array[i];
    }
    // 更新底层数组
    array = newArray;
  }

  // 打印顺序表
  public void display() {
    // 遍历数组打印元素
    for (int i = 0; i < size; i++) {
      System.out.print(array[i] + " ");
    }
    System.out.println();
  }
}

3.3 测试功能

接着我们再写一个测试类，用于测试功能：

public class Main {
    public static void main(String[] args) {
        MyArrayList list = new MyArrayList();

        // 测试默认构造方法
        System.out.println("测试默认构造方法：");
        System.out.println("顺序表是否为空：" + (list.size() == 0)); // 顺序表是否为空：true
        System.out.println("顺序表的大小：" + list.size()); // 顺序表的大小：0
        list.display(); // 顺序表的元素：

        // 测试 add 方法
        System.out.println("\n测试 add 方法：");
        list.add(1);
        list.add(2);
        list.add(3);
        list.display(); // 顺序表的元素：1 2 3

        // 测试 add(pos, data) 方法
        System.out.println("\n测试 add(pos, data) 方法：");
        list.add(1, 5);
        list.display(); // 顺序表的元素：1 5 2 3

        // 测试 contains 方法
        System.out.println("\n测试 contains 方法：");
        System.out.println("顺序表中是否包含元素 2：" + list.contains(2)); // 顺序表中是否包含元素 2：true
        System.out.println("顺序表中是否包含元素 4：" + list.contains(4)); // 顺序表中是否包含元素 4：false

        // 测试 indexOf 方法
        System.out.println("\n测试 indexOf 方法：");
        System.out.println("元素 2 在顺序表中的位置：" + list.indexOf(2)); // 元素 2 在顺序表中的位置：2
        System.out.println("元素 4 在顺序表中的位置：" + list.indexOf(4)); // 元素 4 在顺序表中的位置：-1

        // 测试 get 方法
        System.out.println("\n测试 get 方法：");
        System.out.println("位置 2 上的元素：" + list.get(2)); // 位置 2 上的元素：2

        // 测试 set 方法
        System.out.println("\n测试 set 方法：");
        list.set(1, 4);
        list.display(); // 顺序表的元素：1 4 2 3

        // 测试 remove 方法
        System.out.println("\n测试 remove 方法：");
        list.remove(2);
        list.display(); // 顺序表的元素：1 4 3

        // 测试 size 方法
        System.out.println("\n测试 size 方法：");
        System.out.println("顺序表的大小：" + list.size()); // 顺序表的大小：3

        // 测试 clear 方法
        System.out.println("\n测试 clear 方法：");
        list.clear();
        list.display(); // 顺序表的元素：
        System.out.println("顺序表是否为空：" + (list.size() == 0)); // 顺序表是否为空：true
    }
}

可见输出都符合我们的预期，说明我们模拟实现的 ArrayList 在功能上是完好的，并且没有什么缺陷。

四：ArrayList 的问题及思考

  1. ArrayList 底层使用连续的空间，任意位置插入或删除元素时，需要将该位置后序元素整体往前或者往后搬移，故时间复杂度为 O(N)
  2. 增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。
  3. 增容一般是呈 2 倍的增长，势必会有一定的空间浪费。例如当前容量为 100，满了以后增容到 200，我们再继续插入了 5 个数据，后面没有数据插入了，那么就浪费了 95 个数据空间。

所以应该使用 ArrayList 的场景包括：

  1. 需要频繁进行随机访问的场景。

不应该使用 ArrayList 的场景包括：

  1. 需要频繁进行插入和删除操作，并对性能要求较高的场景。

  2. 列表中的元素数量比较少，可能造成内存浪费的场景。

ice___Cpu
关注
  • 15
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 16
    评论
专栏目录
C#数据结构之顺序表(SeqList)实例详解
09-03
顺序表是一种常见的线性数据结构，它在计算机科学中扮演着重要角色。在C#中，顺序表通常通过数组来实现，因为数组在内存中是连续分配的，这使得我们可以快速地访问任意位置的元素，实现所谓的“随机存取”。 顺序表...
详解（数据结构C语言版）顺序表
10-02
顺序表演示程序
C语言---顺序表（详解）---数据结构
weixin_57535054的博客
02-03 3866
我们直接切入主题 1.首先这次写的顺序表的动态的，因为静态的弊端较多。 2.顺序表的功能函数有：初始化 丶申请动态内存 顺序表的头部，尾部的插入和删除 丶在特定位置的插入和删除 丶打印顺序表 丶释放动态内存 需要用到的头文件 我们先给 类型 重命名 原因是：以后还需要用到顺序表时，插入的不一定是你当前使用的类型，如果要改还需要一个个改，非常麻烦，为了以后方便，我们需要改类型时，直接给 类型重命名 这里改，就可以了，更加节省时间。 创建一个结构体里面包含 1指向动态开辟数组的指针。*a.
数据结构-顺序表详解（含完整代码）
qq_65641647的博客
09-10 6670
数据结构：顺序表详解，里面含有完整代码，对算法的分析，简单明了，一看就会哦。
《Java数据结构入门》顺序表详解
日常学习记录、分享，愿我们都遇见更好的自己，与诸君共勉
04-25 5562
带你手把手自己模拟实现Java数据结构中的顺序表，很详细的哟😁
数据结构：顺序表详解
Zhenyu_Coder的博客
07-30 5576
顺序表作为一种基本的数据结构，在许多应用场景中具有重要的意义和作用，可以提高数据的访问和操作效率，简化算法设计，提高内存利用率。本篇博客将向你详细介绍其模拟过程及全代码
【数据结构篇】线性表1 --- 顺序表、链表 （万字详解！！）
iiiiiihuang的博客
09-03 2494
前言：这篇博客我们重点讲线性表中的顺序表、链表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列... 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。
详解顺序表-顺序表演示源文件
10-02
顺序表演示源文件
C语言实现静态顺序表的实例详解
08-29
在计算机科学中，顺序表是一种基本的数据结构，它是由一系列元素组成的有序集合。静态顺序表是一种特殊的顺序表，它在内存中开辟了一段连续的存储空间，并给它一个名字进行标识。下面我们将深入探讨C语言实现静态...
c语言（7.23）
fhgfyrsg的博客
07-23 413
【代码】c语言（7.23）
重生之“我打数据结构，真的假的？”--3.栈和队列
2301_80374809的博客
07-21 772
栈：一种特殊的线性表，其只允许在进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守LIFO（Last In First Out）的原则。
数据结构之判断完全二叉树详解与示例（C，C++）
qq_35320456的博客
07-23 387
通过上述C和C++的实现示例，我们可以看到判断一个二叉树是否为完全二叉树的基本方法是使用层序遍历。在遍历过程中，我们通过设置一个标记来区分节点是否应该为叶子节点，从而判断二叉树是否满足完全二叉树的条件。这种方法的时间复杂度为O(n)，其中n是二叉树中节点的数量，因为每个节点最多只会被访问一次。在实际应用中，完全二叉树由于其特殊的结构，常用于堆的实现，因为它可以在数组中有效地表示，同时保持堆的操作效率。理解并掌握判断完全二叉树的方法，对于深入理解二叉树结构和相关算法有重要意义。
数据结构（特殊二叉树－线索二叉树）
weixin_65029285的博客
07-22 359
链式二叉树中有很多的空指针，可以让这些空指针指向前一个节点\后一个节点，从而在有序遍历（中序遍历）二叉树时，不需要使用递归而通过循环即可以完成，并且效率要比递归快得多。首先需要有一颗搜索二叉树，然后通过中序遍历并生成线索，通过检查右子树是否为空来决定是否生成线索，让右子树指向下一个节点。bool lflag;// 左子树是否是线索 为真时，左子树是线索 指向前一个节点。bool rflag;// 右子树是否是线索 为真时，右子树是线索 指向下一个节点。
数据结构——单链表OJ题（下）
最新发布
2301_81888634的博客
07-25 583
链表既然包括单链表，就还有其他种类啦~敬请期待“双向链表”~
数据结构（特殊二叉树-平衡二叉树）
weixin_65029285的博客
07-23 950
待删除节点左右子树非空，则根据左右子树的高度，选择高的一边子树，如果是左子树高，选择左子树中的最大节点赋值给待删除节点，然后再左子树中继续删除该最大节点，相当于继续处理情况1或情况2；由于节点的位置要受到相互之间值的影响，并且在往平衡二叉树中添加节点或者删除节点前，二叉树本身是平衡的，所以只可能在最后操作的节点附近不满足平衡条件，因此需要在该过程中对该节点进行判断并调整。如果一个搜索二叉树呈现或接近单支状，它的查找效率很低，很接近链表，因此如果能让它平衡时，查找效率最高。待删除的节点是叶子节点，直接删除。
华清数据结构day5 24-7-22
m0_62859255的博客
07-22 392
【代码】华清数据结构day5 24-7-22。
【数据结构】AVL树(平衡二叉搜索树)
weixin_69380220的博客
07-24 1069
AVL树的相关操作
数据结构——二叉树定义
鲸落博客
07-23 400
二叉树是一种树形数据结构，其中每个节点最多有两个子节点，通常称为左子节点和右子节点。每个子节点本身又可以是一个二叉树。二叉树在计算机科学中有着广泛的应用，例如在搜索算法、排序算法等领域二叉树(Binary Tree)是n(n≥0)个结点的有限集合，该集合 或者为空集(称为空二叉树),或者由一个根结点和两棵互不相交 的、分别称为根结点的左子树和右子树的二叉树组成。
学习记录——day17 数据结构 队列 链式队列
weixin_64918301的博客
07-23 441
1、队列也是操作受限的线性表:所有操作只能在端点处进行，其删除和插入必须在不同端进行2、允许插入操作的一端称为队尾，允许删除操作的一端称为队头3、特点:先进先出(FIFO)4、分类：顺序存储的栈称为顺序栈链式存储的队列，称为链式队列。
数据结构-顺序存储方式详解
内容涵盖了数据结构的基本概念，特别是数据结构与算法之间的关系，以及在实际问题中如何利用数据结构来优化程序设计。" 在计算机科学中，数据结构是组织和存储数据的方式，以便高效地访问和操作这些数据。讲义中...
评论 16
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

ice___Cpu

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

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

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

打赏作者

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

抵扣说明：

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

余额充值