【数据结构】之队列

最新推荐文章于 2022-09-05 21:59:39 发布
最新推荐文章于 2022-09-05 21:59:39 发布
阅读量288 收藏 2
点赞数 1
分类专栏： 数据结构与算法 文章标签： 队列 队列实现 队列原理 数据结构 队列结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/justry_deng/article/details/90330938
版权

笔者日常：
        感谢孤尽(花名)大侠今天给我解答线程安全的问题，在这里推荐孤大侠书籍《码出高效》，带你深入基础，走进阿里规范！

目录

队列基本知识

队列的常见实现方式

         数组实现

         链表实现

队列的常见分类

        数组队列：基于数组的原理进行实现。

        链表队列：基于链表的原理进行实现。

Java对上述队列的代码实现(示例)

        对(数组)顺序队列的(简单)实现

        对(数组)循环队列的(简单)实现

        对链表队列的(简单)实现

队列基本知识：

       队列是一种特殊的操作受限制的线性表，它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，进行插入操作的端称为队尾，进行删除操作的端称为队头。队列的插入操作称为入队，删除操作称为出队。队列就像一列进入隧道的火车，隧道就是队列，火车车厢就是元素，进入隧道就是从隧道的这头(队尾)插入元素；出隧道就是从隧道的另一头(队头)删除元素。队列具有先进先出(FIFO—first in first out)的特点。

队列的常见实现方式：

       队列的实现方式较多，我们常见的主要有两种，分别是数组实现与链表实现。基于数组的队列效率较高，但有长度限制(当然可以在程序内部以新建数组的方式来变相达到动态扩容的效果)。基于链表的队列，要动态创建和删除节点，效率较低，但是可以动态增长。

数组实现：

链表实现：

队列的常见分类：

        分类标准不同，队列分类也不一样。按照入队出队时是否阻塞可分为阻塞队列、非阻塞队列。按照实现方式来分的话，队列可分为数组队列、链表队列等。其中，数组队列按照空间是否可以重复利用来分的话，又可分为顺序队列和循环队列。
注：对于数组队列而言，循环队列要比顺序队列实用得多。

数组队列：基于数组的原理进行实现。

相关概念之溢出(图示说明)：

顺序队列(主要以图示说明)：从队头删除元素，从队尾增加元素。被删除的元素空出来的位置，不会被后来增加的
                                              元素重复利用。

第一种：队头不动，出队列时队头后的所有元素向前移动。

注：一旦有元素出队，那么所有元素都得移动，开销较大。

第二种：队头移动，出队列时队头向后移动一个位置。

注：此方式可能出现假溢出。

循环队列(主要以图示说明)：从队头删除元素，从队尾增加元素。被删除的元素空出来的位置，会被后来增加的元素重复利用。

链表队列：基于链表的原理进行实现。

注：可结合上文中的链表实现gif动图进行理解。

Java对上述队列的代码实现(示例)：

声明：这里只是简单的实现，如果想要了解更全面实现方式的话，推荐阅读各种阻塞非阻塞队列的源码。

先给出一个下面三个队列实现中都会用到的异常类：

对(数组)顺序队列的(简单)实现：

import java.io.Serializable;
import java.util.Arrays;

/**
 * (简单实现)顺序队列
 *
 * @author JustryDeng
 * @date 2019/5/18 21:19
 */
public class SequenceQueue<E> implements Serializable{

    private static final long serialVersionUID = -807097163996913371L;

    /** 元素容器 */
    private final Object[] items;

    /** 队列的容量(即:数组的长度) */
    private int capacity;

    /** 队头 */
    private int front;

    /** 队尾 */
    private int rear;

    /**
     * 构造器
     *
     * @param capacity
     *            队列的容量
     * @date 2019/5/18 21:55
     */
    public SequenceQueue(int capacity) {
        this.capacity = capacity;
        items = new Object[capacity];
        front = 0;
        rear = 0;
    }

    /**
     * 入队
     *
     * @param e
     *            入队的元素
     * @date 2019/5/18 22:27
     */
    public void offer(E e) {
        if (e == null) {
            throw new IllegalArgumentException("arg must be not null!");
        }
        if (rear >= capacity) {
            throw new MyQueueException("the queue already full!");
        }
        items[rear] = e;
        rear++;
    }

    /**
     * 出队
     *
     * @return  出队的那个元素
     * @date 2019/5/18 22:25
     */
    public E poll() {
        if (isEmpty()) {
            throw new MyQueueException("the queue is empty!");
        }
        // 保留队列的front端的元素的值
        E oldValue = itemAt(front);
        // 释放队列的front端的元素
        items[front] = null;
        front++;
        return oldValue;
    }

    /**
     * 返回队列头元素,但不会将该元素出列
     *
     * @return 队列头元素
     * @date 2019/5/18 22:07
     */
    public E peek() {
        if (isEmpty()) {
            throw new MyQueueException("the queue is empty!");
        }
        return itemAt(front);
    }

    /**
     * 返回指定位置处的元素
     *
     * @param index
     *          索引位置
     *
     * @return  返回index位置处的元素
     * @date 2019/5/18 22:21
     */
    @SuppressWarnings("unchecked")
    public E itemAt(int index) {
        return (E) items[index];
    }

    /**
     * 判断队列是否为空队列
     *
     * @return  是/否
     * @date 2019/5/18 22:04
     */
    public boolean isEmpty() {
        return rear == front;
    }

    /**
     * 判断队列是否已满
     *
     * @return  是/否
     * @date 2019/5/18 22:04
     */
    public boolean isFull() {
        return rear >= capacity;
    }

    /**
     * 获取队列的实际有效大小(即:获取队列中元素的个数)
     *
     * @return  获取当前队列的大小
     * @date 2019/5/18 21:54
     */
    public int size() {
        return rear - front;
    }

    /**
     * 清空队列
     *
     * @date 2019/5/18 22:04
     */
    public void clear() {
        // 将数组所有元素赋为null
        Arrays.fill(items, null);
        // 首尾指针重置
        front = 0;
        rear = 0;
    }

    @Override
    public String toString() {
        if (isEmpty()) {
            return "[]";
        } else {
            StringBuilder sb = new StringBuilder("[");
            for (int i = front; i < rear; i++) {
                sb.append(items[i].toString())
                  .append( ", ");
            }
            int len = sb.length();
            return sb.delete(len - 2, len).append("]").toString();
        }
    }

    /**
     * 测试一下
     *
     * @author JustryDeng
     * @date 2019/5/19 1:14
     */
    public static void main(String[] args) {
        SequenceQueue<String> queue = new SequenceQueue<>(5);
        // 入队
        queue.offer("A");
        queue.offer("B");
        queue.offer("C");
        // 出队(出队后，元素就不在队列中了)
        System.out.println(queue.poll());
        System.out.println(queue.poll());
        // 队列是否为空
        System.out.println(queue.isEmpty());
        // 队列中元素个数
        System.out.println(queue.size());
        // 获取队列中的头元素(此操作后，该元素仍然在队列中)
        System.out.println(queue.peek());
        // 入队
        queue.offer("D");
        queue.offer("E");
        // 队列是否已满
        System.out.println(queue.isFull());
        // 验证queue的toString函数
        System.out.println(queue);
        // 清空队列
        queue.clear();
        queue.offer("F");
        // 验证queue的toString函数
        System.out.println(queue);
        // 队列中元素个数
        System.out.println(queue.size());
    }
}

注：这里以实现第二种顺序队列为例。

对(数组)循环队列的(简单)实现：

import java.io.Serializable;
import java.util.Arrays;

/**
 * (简单实现)循环队列
 *
 * @author JustryDeng
 * @date 2019/5/18 18:58
 */
public class CircleQueue<E> implements Serializable {

    /** 元素容器 */
    private final Object[] items;

    /** 队列的容量(即:数组的长度) */
    private int capacity;

    /** 队头 */
    private int front;

    /** 队尾 */
    private int rear;

    /**
     * 构造器
     *
     * @param capacity
     *         队列的容量
     * @date 2019/5/18 21:55
     */
    public CircleQueue(int capacity) {
        this.capacity = capacity;
        items = new Object[capacity];
        front = 0;
        rear = 0;
    }

    /**
     * 入队
     *
     * @param e
     *         入队的元素
     * @date 2019/5/18 22:27
     */
    public void offer(E e) {
        if (e == null) {
            throw new IllegalArgumentException("arg must be not null!");
        }
        if (rear - front >= capacity) {
            throw new MyQueueException("the queue already full!");
        }
        int currIndex = rear % capacity;
        items[currIndex] = e;
        rear++;
    }

    /**
     * 出队
     *
     * @return 出队的那个元素
     * @date 2019/5/18 22:25
     */
    public E poll() {
        if (isEmpty()) {
            throw new MyQueueException("the queue is empty!");
        }
        int currIndex = front % capacity;
        E oldValue = itemAt(currIndex);
        items[currIndex] = null;
        front++;
        return oldValue;
    }

    /**
     * 返回队列头元素,但不会将该元素出列
     *
     * @return 队列头元素
     * @date 2019/5/18 22:07
     */
    public E peek() {
        if (isEmpty()) {
            throw new MyQueueException("the queue is empty!");
        }
        return itemAt(front % capacity);
    }

    /**
     * 返回指定位置处的元素
     *
     * @param index
     *         索引位置
     * @return 返回index位置处的元素
     * @date 2019/5/18 22:21
     */
    @SuppressWarnings("unchecked")
    public E itemAt(int index) {
        return (E) items[index];
    }

    /**
     * 判断队列是否为空队列
     *
     * @return 是/否
     * @date 2019/5/18 22:04
     */
    public boolean isEmpty() {
        return rear == front;
    }

    /**
     * 判断队列是否已满
     *
     * @return  是/否
     * @date 2019/5/18 22:04
     */
    public boolean isFull() {
        return rear - front >= capacity;
    }

    /**
     * 获取队列的实际有效大小(即:获取队列中元素的个数)
     *
     * @return 获取当前队列的大小
     * @date 2019/5/18 21:54
     */
    public int size() {
        return rear - front;
    }

    /**
     * 清空队列
     *
     * @date 2019/5/18 22:04
     */
    public void clear() {
        // 将数组所有元素赋为null
        Arrays.fill(items, null);
        // 首尾指针重置
        front = 0;
        rear = 0;
    }

    @Override
    public String toString() {
        if (isEmpty()) {
            return "[]";
        } else {
            StringBuilder sb = new StringBuilder("[");
            int curIndex;
            for (int i = front; i < rear; i++) {
                curIndex = i % capacity;
                sb.append(items[curIndex].toString())
                  .append(", ");
            }
            int len = sb.length();
            return sb.delete(len - 2, len).append("]").toString();
        }
    }

    /**
     * 测试一下
     *
     * @author JustryDeng
     * @date 2019/5/19 1:14
     */
    public static void main(String[] args) {
        CircleQueue<String> queue = new CircleQueue<>(5);
        // 入队
        queue.offer("A");
        queue.offer("B");
        queue.offer("C");
        queue.offer("D");
        // 出队(出队后，元素就不在队列中了)
        System.out.println(queue.poll());
        System.out.println(queue.poll());
        // 队列是否为空
        System.out.println(queue.isEmpty());
        // 队列中元素个数
        System.out.println(queue.size());
        // 获取队列中的头元素(此操作后，该元素仍然在队列中)
        System.out.println(queue.peek());
        // 入队
        queue.offer("E");
        queue.offer("F");
        queue.offer("G");
        // 验证queue的toString函数
        System.out.println(queue);
        // 队列是否已满
        System.out.println(queue.isFull());
        // 清空队列
        queue.clear();
        // 验证queue的toString函数
        System.out.println(queue);
        // 队列是否已满
        System.out.println(queue.isFull());
    }

}

对链表队列的(简单)实现：

import java.io.Serializable;

/**
 * (简单实现)链式(链表)队列
 *
 * @author JustryDeng
 * @date 2019/5/19 1:32
 */
public class LinkQueue<E> implements Serializable{

    private static final long serialVersionUID = 3748038449750184916L;
    
    /**
     * 定义一个内部类Node，Node实例代表链队列的节点
     *
     * @author JustryDeng
     * @date 2019/5/19 1:31
     */
    private class Node {
        
        /** 此节点的数据 */
        private E data;

        /** 指向下个节点的引用 */
        private Node next;

        /** 全参构造 */
        private Node(E data, Node next) {
            this.data = data;
            this.next = next;
        }
    }

    /** 头节点 */
    private Node front;

    /** 尾节点 */
    private Node rear;

    /** 此链式队列中已包含的节点数 */
    private int size;

    /**
     * 空链队列 构造
     */
    public LinkQueue() {
        front = null;
        rear = null;
        size = 0;
    }

    /**
     * 入队
     *
     * @param e
     *         入队的元素
     * @date 2019/5/19 1:36
     */
    public void offer(E e) {
        // 如果该链队列还是空链队列
        if (front == null) {
            if (e == null) {
                throw new IllegalArgumentException("arg must be not null!");
            }
            front = new Node(e, null);
            // 只有一个节点，front、rear都指向该节点
            rear = front;
        } else {
            // 创建新节点
            Node newNode = new Node(e, null);
            // 让当前尾节点的next指向新增的节点
            rear.next = newNode;
            // 更新尾节点引用，以新节点作为新的尾节点
            rear = newNode;
        }
        size++;
    }

    /**
     * 出队
     *
     * @return 出队的那个元素
     * @date 2019/5/18 22:25
     */
    public E poll() {
        if (isEmpty()) {
            throw new MyQueueException("the queue is empty!");
        }
        Node oldFront = front;
        front = front.next;
        oldFront.next = null;
        size--;
        return oldFront.data;
    }

    /**
     * 返回队列头元素,但不会将该元素出列
     *
     * @return 队列头元素
     * @date 2019/5/18 22:07
     */
    public E peek() {
        if (isEmpty()) {
            throw new MyQueueException("the queue is empty!");
        }
        return front.data;
    }

    /**
     * 判断队列是否为空队列
     *
     * @return 是/否
     * @date 2019/5/18 22:04
     */
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * 获取此链式队列中已包含的节点数
     *
     * @return  此链式队列中已包含的节点数
     * @date 2019/5/19 1:36
     */
    public int size() {
        return size;
    }

    /**
     * 清空队列
     *
     * @date 2019/5/18 22:04
     */
    public void clear() {
        front = null;
        rear = null;
        size = 0;
    }

    @Override
    public String toString() {
        // 链队列为空链队列时
        if (isEmpty()) {
            return "[]";
        } else {
            StringBuilder sb = new StringBuilder("[");
            for (Node current = front; current != null; current = current.next) {
                sb.append(current.data.toString())
                  .append(", ");
            }
            int len = sb.length();
            return sb.delete(len - 2, len).append("]").toString();
        }
    }

    /**
     * 测试一下
     *
     * @author JustryDeng
     * @date 2019/5/19 1:14
     */
    public static void main(String[] args) {
        LinkQueue<String> queue = new LinkQueue<>();
        // 入队
        queue.offer("A");
        queue.offer("B");
        queue.offer("C");
        // 出队(出队后，元素就不在队列中了)
        System.out.println(queue.poll());
        System.out.println(queue.poll());
        // 队列是否为空
        queue.offer("D");
        queue.offer("E");
        System.out.println(queue.isEmpty());
        // 队列中元素个数
        System.out.println(queue.size());
        // 获取队列中的头元素(此操作后，该元素仍然在队列中)
        System.out.println(queue.peek());
        // 入队
        queue.offer("F");
        queue.offer("G");
        // 验证queue的toString函数
        System.out.println(queue);
        // 清空队列
        queue.clear();
        // 验证queue的toString函数
        System.out.println(queue);
        // 队列中元素个数
        System.out.println(queue.size());
    }
}

 

^_^ 如有不当之处，欢迎指正

^_^ 参考链接
               https://baike.baidu.com/item/%E9%...7/14580481?fr=aladdin
               https://blog.csdn.net/zhang21722668/article/details/82155301
               https://www.jb51.net/article/130858.htm

^_^ 学习视频
               51CTO学院《数据结构与算法》，讲师张晨光

^_^ 本文已被收录进《程序员成长笔记(五)》，笔者JustryDeng

justry_deng
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
队列的链表实现（C语言）
sunlanchang的博客
07-26 1686
#include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; struct QueueRecord; typedef struct QueueRecord *Queue; typedef struct Node *QueueNode; typedef int ElementType; // 规定队列的最大长度 #define MAXSIZE 100 /...
Java数据结构之队列的简单定义与使用方法
08-29
Java数据结构之队列的简单定义与使用方法 Java数据结构之队列是计算机科学中的一种基本数据结构，具有先进先出的特点。队列是一种特殊的线性表，元素的添加和删除只能在队列的两端进行，即队头和队尾。Java中实现...
队列
qq_43271202的博客
06-30 93
队列 背景 今天复习顺序结构实现的队列、链表结构实现的队列以及利用数组实现的循环队列 基本理论 队列的定义：队列是指 插入操作在一端（队尾）进行、删除操作在另一端（队首）进行的线性表。即先进先出线性表。 例子： 队列可进行的操作： 代码实现 队列可进行的操作（定义接口） public interface IQueue<T> where T : IComparable<...
Java 队列（Queue）用法
u011277123的博客
11-10 2012
java新人学习 2016-11-08 16:14 队列是一种特殊的线性表，它只允许在表的前端进行删除操作，而在表的后端进行插入操作。 LinkedList类实现了Queue接口，因此我们可以把LinkedList当成Queue来用。 以下实例演示了队列（Queue）的用法： /* author by w3cschool.cc Main.java */ import jav
队列（链表实现）
Nick
12-13 457
1.思路 定义结构体node表示链表里的节点，结构体linklist表示链表，选用两个首尾指针进行基本操作。2.代码#include<iostream> using namespace std;struct node { int value; node *next; };struct linklist { //带头尾指针的链表 node* head; node* t
Queue接口分析：add和offer区别，remove和poll方法到底啥区别
qq_36101933的博客
10-19 6396
往队列中添加元素有两个方法，分布是add和offer方法，两者的入参和返回值都一样，或许很多同学都奇怪，为什么，要有这两个功能类似（都是添加元素），但方法名不一样的方法，看看源码的注释 以下为Queue接口中方法定义： ``` public interface Queue&lt;E&gt; extends Collection&lt;E&gt; { /* * add方法，...
数据结构之队列
jiaomubai的博客
02-05 3540
什么是队列 队列（queue）是一种线性数据结构。与同为线性数据结构的栈不同的是队列中的元素遵循的是先进先出（First In First Out）的规则，和在现实中排队一样，讲究的是先来后到的原则。队列出口端叫做队头（front），队列的入口端叫做队尾（rear）。 与栈类似，队列这种线性数据结构既可以用数组来实现，也可以用链表来实现。用数组来实现时，我们可以自行规定队尾的位置，比如说规定最后一个元素的下一个位置为队尾，或者规定最后一个元素所在的位置为队尾，这两种都行，毕竟是自己实现的。本文规定最后一
数据结构之队列总结
Grand.的博客
05-17 1799
数据结构之队列
线性数据结构之队列(Queue)
热门推荐
刘跃辉的博客
09-05 9万+
队列是一种用来存储数据的数据结构 , 与链表和栈类似 , 数据到达的次序是队列的关键 , 类似于生活中我们在排队购买东西时 , 第一个人是队首 , 最后一个人是队尾 , 第一个人先买到东西后离开 , 这个时候第二个人便成了队首 , 以此类推…队列中第一个插入的元素也是第一个被删除的元素 , 所以队列是一种先进先出(First In First Out 简称 FIFO)或者后进后出(Last In Last Out 简称 LILO)的线性表。
数据结构之队列.rar
04-07
这个压缩包文件“数据结构之队列.rar”显然是关于队列数据结构的深入探讨，特别是结合了C++编程语言的应用。 队列的基本概念： 队列是一种线性数据结构，其一端允许元素的插入（称为后端或尾部），另一端允许元素的...
数据结构之队列的java实现
12-22
队列也是一种数据结构，类似于栈，只是与栈相反，在队列中先插入的数据也先被移除，即先进先出(FIFO，First In First Out)。队列可以理解成排队，比如，食堂窗口排的队，越在前面的，越早得到服务而先离开。在银行...
数据结构-使用javascript讲解数据结构之队列.zip
最新发布
02-12
在这个专题中，我们重点关注的是使用JavaScript语言来讲解的数据结构之一：队列。队列是一种线性数据结构，其操作特性类似于现实生活中的排队等候，遵循“先进先出”（FIFO）的原则。 在JavaScript中，队列可以通过...
数据结构之队列（Java版）
01-21
1.队列概述：队列是一个有序表，可以用数组或链表实现（本篇讲的是用数组实现），遵循先入先出（FIFO）原则，即先存入队列的数据，要先取出，后存入的要后取出。 2.用数组实现队列的思路 使用数组的声明如下图，其中...
【数据结构】之双向链表、双端(双向)链表、循环(双向)链表
JustryDeng
05-21 1837
双向链表、双端(双向)链表、循环(双向)链表示意(简)图： 声明：下面各图中，箭头指向的是整个节点，而不是指向节点中的prior或next。 双向链表：只有一个指针指向最开始的结点。 双端(双向)链表：有两个指针分别指向两端的节点。 循环(双向)链表：指向形成一个闭环。 双端(双向)链表的Java实现(简单示例)： 注：双向链表、双端(双向)链表、循环(双向)链表的实现思路...
【高级排序】之桶排序
JustryDeng
05-03 1505
算法评价： 时间复杂度：O(N)。N为待排序元素的个数。 注：前提是数据服从均匀分布，它的平均时间复杂度才为O(N)。 注：时间复杂度实际为，再通过一些列化简后，可得到O(N)的时间复杂度，具体化简 过程可详见《算法导论》。 注：即使输入数据不服从均匀分布，桶排序也仍然可以在线性时间内完成。只要输入数据满足下列性质:所有桶的 大小（即：桶内元素的个数)的平方和与...
【数据结构】之单向链表、双端(单向)链表、循环(单向)链表
JustryDeng
05-21 1500
单向链表、双端(单向)链表、循环(单向)链表示意(简)图： 单向链表：只有一个指针指向头结点。 双端(单向)链表：有一个指针指向头结点，还有一个指针指向尾节点。 循环(单向)链表：指向形成一个闭环。 双端(单向)链表的Java实现(简单示例)： 注：单向链表、双端(单向)链表、循环(单向)链表的实现思路几乎一样，这里以实现双端(单向)链表示例。 /** * 双端链表 简...
时间复杂度、空间复杂度、稳定性、数据结构基础概念
JustryDeng
04-24 1179
开启算法与数据结构学习之旅咯~ 时间复杂度与空间复杂度是算法的两大考量标准。稳定性也是算法的一个重要标准。 时间复杂度： 时间复杂度是对处理规模量为n的数据，执行算法所花的时间的度量。 注：站在宏观上(以大时间单位)来讲，程序在计算机上执行的速度是非常快的，各种算法的执行消耗时间几乎一样， 所以比较消耗了的时间也就失去了意义，所以时间复杂度也可以理解是：处理规...
【高级排序】之快速排序
JustryDeng
05-11 458
算法评价： 时间复杂度：。 注：快速排序最坏情况下的时间复杂度是，其平均时间复杂度是。 空间复杂度：。 稳定性：不稳定。 适用数据规模量：大规模。 注：快速排序通常是实际排序中的最好的选择，因为它的平均性能非常好。快速排序的平均时间复杂度为， 相比起基本排序(冒泡、插入、选择排序)的要快得多，相比起同样时间复杂度的归并排序，快速排序的 ...
【基础排序】之冒泡排序
JustryDeng
11-25 349
虽然很简单，但也要踏踏实实一步一步的进行学习啊！ 算法评价： 时间复杂度：平方阶。 空间复杂度：常量阶。 稳定性：稳定。 适用数据规模量：小规模。 算法复杂度与数据规模量关系图： 算法原理简述(小白可读)： 冒泡排序的原理：若一个数组中共有n个元素，则一共会比较n-1轮，每一轮又会比较很多次。 第一轮， 第一次：第一个数和...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值