java栈和队列实现

最新推荐文章于 2022-09-29 16:06:08 发布
最新推荐文章于 2022-09-29 16:06:08 发布
阅读量494 收藏
点赞数
分类专栏： 数据结构

顺序栈的实现

import java.util.Arrays;
public class SequenceStack<T>
{
 private int DEFAULT_SIZE = 10;
 //保存数组的长度。
 private int capacity;
 //定义当底层数组容量不够时，程序每次增加的数组长度
 private int capacityIncrement = 0;
 //定义一个数组用于保存顺序栈的元素
 private Object[] elementData;
 //保存顺序栈中元素的当前个数
 private int size = 0;
 //以默认数组长度创建空顺序栈
 public SequenceStack()
 {
  capacity = DEFAULT_SIZE;
  elementData = new Object[capacity];
 }
 //以一个初始化元素来创建顺序栈
 public SequenceStack(T element)
 {
  this();
  elementData[0] = element;
  size++;
 }
 /**
  * 以指定长度的数组来创建顺序栈
  * @param element 指定顺序栈中第一个元素
  * @param initSize 指定顺序栈底层数组的长度
  */
 public SequenceStack(T element , int initSize)
 {
  this.capacity = initSize;
  elementData = new Object[capacity];
  elementData[0] = element;
  size++;
 }
 /**
  * 以指定长度的数组来创建顺序栈
  * @param element 指定顺序栈中第一个元素
  * @param initSize 指定顺序栈底层数组的长度
  * @param capacityIncrement 指定当顺序栈底层数组的长度不够时，底层数组每次增加的长度
  */
 public SequenceStack(T element , int initSize
  , int capacityIncrement)
 {
  this.capacity = initSize;
  this.capacityIncrement = capacityIncrement;
  elementData = new Object[capacity];
  elementData[0] = element;
  size++;
 }
 //获取顺序栈的大小
 public int length()
 {
  return size;
 }
 //入栈
 public void push(T element)
 {
  ensureCapacity(size + 1);
  elementData[size++] = element;
 }
 //很麻烦，而且性能很差
 private void ensureCapacity(int minCapacity)
 {
  //如果数组的原有长度小于目前所需的长度
  if (minCapacity > capacity)
  {
   if (capacityIncrement > 0)
   {
    while (capacity < minCapacity)
    {
     //不断地将capacity长度加capacityIncrement，
     //直到capacity大于minCapacity为止
     capacity += capacityIncrement;
    }
   }
   else
   {
    //不断地将capacity * 2，直到capacity大于minCapacity为止
    while (capacity < minCapacity)
    {
     capacity <<= 1;
    }
   }
   elementData = Arrays.copyOf(elementData , capacity);
  }
 }
 //出栈
    public T pop()
 {
  T oldValue = (T)elementData[size - 1];
  //释放栈顶元素
  elementData[--size] = null;
  return oldValue;
 }
 //返回栈顶元素，但不删除栈顶元素
    public T peek()
 {
  return (T)elementData[size - 1];
 }
 //判断顺序栈是否为空栈
 public boolean empty()
 {
  return size == 0;
 }
 //清空顺序栈
 public void clear()
 {
  //将底层数组所有元素赋为null
  Arrays.fill(elementData , null);
  size = 0;
 }
 public String toString()
 {
  if (size == 0)
  {
   return "[]";
  }
  else
  {
   StringBuilder sb = new StringBuilder("[");
   for (int i = size - 1  ; i > -1 ; i-- )
   {
    sb.append(elementData[i].toString() + ", ");
   }
   int len = sb.length();
   return sb.delete(len - 2 , len).append("]").toString();
  }
 }
 
 public static void main(String[] args)
 {
  SequenceStack<String> stack =
   new SequenceStack<String>();
  //不断地入栈
  stack.push("aaaa");
  stack.push("bbbb");
  stack.push("cccc");
  stack.push("dddd");
  System.out.println(stack);
  //访问栈顶元素
  System.out.println("访问栈顶元素：" + stack.peek());
  //弹出一个元素
  System.out.println("第一次弹出栈顶元素：" + stack.pop());
  //再次弹出一个元素
  System.out.println("第二次弹出栈顶元素：" + stack.pop());
  System.out.println("两次pop之后的栈：" + stack);
 }
}

链式栈的实现

public class LinkStack<T>
{
 //定义一个内部类Node，Node实例代表链栈的节点。
 private class Node
 {
  //保存节点的数据
  private T data;
  //指向下个节点的引用
  private Node next;
  //无参数的构造器
  public Node()
  {
  }
  //初始化全部属性的构造器
  public Node(T data , Node next)
  {
   this.data = data;
   this.next = next;
  }
 }
 //保存该链栈的栈顶元素
 private Node top;
 //保存该链栈中已包含的节点数
 private int size;
 //创建空链栈
 public LinkStack()
 {
  //空链栈，top的值为null
  top = null;
 }
 //以指定数据元素来创建链栈，该链栈只有一个元素
 public LinkStack(T element)
 {
  top = new Node(element , null);
  size++;
 }
 //返回链栈的长度 
 public int length()
 {
  return size;
 }
 //进栈
 public void push(T element)
 {
  //让top指向新创建的元素，新元素的next引用指向原来的栈顶元素
  top = new Node(element , top);
  size++;
 }
 //出栈
    public T pop()
 {
  Node oldTop = top;
  //让top引用指向原栈顶元素的下一个元素
  top = top.next;
  //释放原栈顶元素的next引用
  oldTop.next = null;
  size--;
  return oldTop.data;
 }
 //访问栈顶元素，但不删除栈顶元素
 public T peek()
 {
  return top.data;
 }
 //判断链栈是否为空栈
 public boolean empty()
 {
  return size == 0;
 }
 //清空链栈
 public void clear()
 {
  //将底层数组所有元素赋为null
  top = null;
  size = 0;
 }
 public String toString()
 {
  //链栈为空链栈时
  if (empty())
  {
   return "[]";
  }
  else
  {
   StringBuilder sb = new StringBuilder("[");
   for (Node current = top ; current != null
    ; current = current.next )
   {
    sb.append(current.data.toString() + ", ");
   }
   int len = sb.length();
   return sb.delete(len - 2 , len).append("]").toString();
  }
 }
 
 public static void main(String[] args)
 {
  LinkStack<String> stack =
   new LinkStack<String>();
  //不断地入栈
  stack.push("aaaa");
  stack.push("bbbb");
  stack.push("cccc");
  stack.push("dddd");
  System.out.println(stack);
  //访问栈顶元素
  System.out.println("访问栈顶元素：" + stack.peek());
  //弹出一个元素
  System.out.println("第一次弹出栈顶元素：" + stack.pop());
  //再次弹出一个元素
  System.out.println("第二次弹出栈顶元素：" + stack.pop());
  System.out.println("两次pop之后的栈：" + stack);
 }
}

顺序队列的实现

import java.util.Arrays;
public class SequenceQueue<T>
{
 private int DEFAULT_SIZE = 10;
 //保存数组的长度。
 private int capacity;
 //定义一个数组用于保存顺序队列的元素
 private Object[] elementData;
 //保存顺序队列中元素的当前个数
 private int front = 0;
 private int rear = 0;
 //以默认数组长度创建空顺序队列
 public SequenceQueue()
 {
  capacity = DEFAULT_SIZE;
  elementData = new Object[capacity];
 }
 //以一个初始化元素来创建顺序队列
 public SequenceQueue(T element)
 {
  this();
  elementData[0] = element;
  rear++;
 }
 /**
  * 以指定长度的数组来创建顺序队列
  * @param element 指定顺序队列中第一个元素
  * @param initSize 指定顺序队列底层数组的长度
  */
 public SequenceQueue(T element , int initSize)
 {
  this.capacity = initSize;
  elementData = new Object[capacity];
  elementData[0] = element;
  rear++;
 }
 //获取顺序队列的大小
 public int length()
 {
  return rear - front;
 }
 //插入队列
 public void add(T element)
 {
  if (rear > capacity - 1)
  {
   throw new IndexOutOfBoundsException("队列已满的异常");
  }
  elementData[rear++] = element;
 }
 //移除队列
    public T remove()
 {
  if (empty())
  {
   throw new IndexOutOfBoundsException("空队列异常");
  }
  //保留队列的rear端的元素的值
  T oldValue = (T)elementData[front];
  //释放队列的rear端的元素
  elementData[front++] = null;
  return oldValue;
 }
 //返回队列顶元素，但不删除队列顶元素
    public T element()
 {
  if (empty())
  {
   throw new IndexOutOfBoundsException("空队列异常");
  }
  return (T)elementData[front];
 }
 //判断顺序队列是否为空队列
 public boolean empty()
 {
  return rear == front;
 }
 //清空顺序队列
 public void clear()
 {
  //将底层数组所有元素赋为null
  Arrays.fill(elementData , null);
  front = 0;
  rear = 0;
 }
 public String toString()
 {
  if (empty())
  {
   return "[]";
  }
  else
  {
   StringBuilder sb = new StringBuilder("[");
   for (int i = front  ; i < rear ; i++ )
   {
    sb.append(elementData[i].toString() + ", ");
   }
   int len = sb.length();
   return sb.delete(len - 2 , len).append("]").toString();
  }
 }
 public static void main(String[] args)
 {
  SequenceQueue<String> queue = new SequenceQueue<String>();
  //依次将4个元素加入队列
  queue.add("aaaa");
  queue.add("bbbb");
  queue.add("cccc");
  queue.add("dddd");
  System.out.println(queue);
  System.out.println("访问队列的front端元素:"
   + queue.element());
  System.out.println("移除队列的front端元素:"
   + queue.remove());
  System.out.println("移除队列的front端元素:"
   + queue.remove());
  System.out.println("两次调用remove方法后的队列："
   + queue);

 }
}

循环队列的实现

import java.util.Arrays;
public class LoopQueue<T>
{
 private int DEFAULT_SIZE = 10;
 //保存数组的长度。
 private int capacity;
 //定义一个数组用于保存循环队列的元素
 private Object[] elementData;
 //保存循环队列中元素的当前个数
 private int front = 0;
 private int rear = 0;
 //以默认数组长度创建空循环队列
 public LoopQueue()
 {
  capacity = DEFAULT_SIZE;
  elementData = new Object[capacity];
 }
 //以一个初始化元素来创建循环队列
 public LoopQueue(T element)
 {
  this();
  elementData[0] = element;
  rear++;
 }
 /**
  * 以指定长度的数组来创建循环队列
  * @param element 指定循环队列中第一个元素
  * @param initSize 指定循环队列底层数组的长度
  */
 public LoopQueue(T element , int initSize)
 {
  this.capacity = initSize;
  elementData = new Object[capacity];
  elementData[0] = element;
  rear++;
 }
 //获取循环队列的大小
 public int length()
 {
  if (empty())
  {
   return 0;
  }
  return rear > front ? rear - front
   : capacity - (front - rear);
 }
 //插入队列
 public void add(T element)
 {
  if (rear == front
   && elementData[front] != null)
  {
   throw new IndexOutOfBoundsException("队列已满的异常");
  }
  elementData[rear++] = element;
  //如果rear已经到头，那就转头
  rear = rear == capacity ? 0 : rear;
 }
 //移除队列
 public T remove()
 {
  if (empty())
  {
   throw new IndexOutOfBoundsException("空队列异常");
  }
  //保留队列的rear端的元素的值
  T oldValue = (T)elementData[front];
  //释放队列的rear端的元素
  elementData[front++] = null;
  //如果front已经到头，那就转头
  front = front == capacity ? 0 : front;
  return oldValue;
 }
 //返回队列顶元素，但不删除队列顶元素
 public T element()
 {
  if (empty())
  {
   throw new IndexOutOfBoundsException("空队列异常");
  }
  return (T)elementData[front];
 }
 //判断循环队列是否为空队列
 public boolean empty()
 {
  //rear==front且rear处的元素为null
  return rear == front
   && elementData[rear] == null;
 }
 //清空循环队列
 public void clear()
 {
  //将底层数组所有元素赋为null
  Arrays.fill(elementData , null);
  front = 0;
  rear = 0;
 }
 public String toString()
 {
  if (empty())
  {
   return "[]";
  }
  else
  {
   //如果front < rear，有效元素就是front到rear之间的元素
   if (front < rear)
   {
    StringBuilder sb = new StringBuilder("[");
    for (int i = front  ; i < rear ; i++ )
    {
     sb.append(elementData[i].toString() + ", ");
    }
    int len = sb.length();
    return sb.delete(len - 2 , len).append("]").toString();
   }
   //如果front >= rear，有效元素为front->capacity之间、0->front之间的
   else
   {
    StringBuilder sb = new StringBuilder("[");
    for (int i = front  ; i < capacity ; i++ )
    {
     sb.append(elementData[i].toString() + ", ");
    }
    for (int i = 0 ; i < rear ; i++)
    {
     sb.append(elementData[i].toString() + ", ");
    }
    int len = sb.length();
    return sb.delete(len - 2 , len).append("]").toString();
   }
  }
 }
 public static void main(String[] args)
 {
  LoopQueue<String> queue
   = new LoopQueue<String>("aaaa" , 3);
  //添加两个元素
  queue.add("bbbb");
  queue.add("cccc");
  //此时队列已满
  System.out.println(queue);
  //删除一个元素后，队列可以再多加一个元素
  queue.remove();
  System.out.println("删除一个元素后的队列：" + queue);
  //再次添加一个元素，此时队列又满
  queue.add("dddd");
  System.out.println(queue);
  System.out.println("队列满时的长度：" + queue.length());
  //删除一个元素后，队列可以再多加一个元素
  queue.remove();
  //再次加入一个元素，此时队列又满
  queue.add("eeee");
  System.out.println(queue);
 }
}

链式队列的实现

public class LinkQueue<T>
{
 //定义一个内部类Node，Node实例代表链队列的节点。
 private class Node
 {
  //保存节点的数据
  private T data;
  //指向下个节点的引用
  private Node next;
  //无参数的构造器
  public Node()
  {
  }
  //初始化全部属性的构造器
  public Node(T data ,  Node next)
  {
   this.data = data;
   this.next = next;
  }
 }
 //保存该链队列的头节点
 private Node front;
 //保存该链队列的尾节点
 private Node rear;
 //保存该链队列中已包含的节点数
 private int size;
 //创建空链队列
 public LinkQueue()
 {
  //空链队列，front和rear都是null
  front = null;
  rear = null;
 }
 //以指定数据元素来创建链队列，该链队列只有一个元素
 public LinkQueue(T element)
 {
  front = new Node(element , null);
  //只有一个节点，front、rear都指向该节点
  rear = front;
  size++;
 }
 //返回链队列的长度 
 public int length()
 {
  return size;
 }
 //将新元素加入队列
 public void add(T element)
 {
  //如果该链队列还是空链队列
  if (front == null)
  {
   front = new Node(element , null);
   //只有一个节点，front、rear都指向该节点
   rear = front;
  }
  else
  {
   //创建新节点
   Node newNode = new Node(element , null);
   //让尾节点的next指向新增的节点
   rear.next = newNode;
   //以新节点作为新的尾节点
   rear = newNode;
  }
  size++;
 }
 //删除队列front端的元素
 public T remove()
 {
  Node oldFront = front;
  front = front.next;
  oldFront.next = null;
  size--;
  return oldFront.data;
 }
 //访问链式队列中最后一个元素
 public T element()
 {
  return rear.data;
 }
 //判断链式队列是否为空队列
 public boolean empty()
 {
  return size == 0;
 }
 //清空链队列
 public void clear()
 {
  //将front、rear两个节点赋为null
  front = null;
  rear = null;
  size = 0;
 }
 public String toString()
 {
  //链队列为空链队列时
  if (empty())
  {
   return "[]";
  }
  else
  {
   StringBuilder sb = new StringBuilder("[");
   for (Node current = front ; current != null
    ; current = current.next )
   {
    sb.append(current.data.toString() + ", ");
   }
   int len = sb.length();
   return sb.delete(len - 2 , len).append("]").toString();
  }
 }
 
 public static void main(String[] args)
 {
  LinkQueue<String> queue
   = new LinkQueue<String>("aaaa");
  //添加两个元素
  queue.add("bbbb");
  queue.add("cccc");
  System.out.println(queue);
  //删除一个元素后
  queue.remove();
  System.out.println("删除一个元素后的队列：" + queue);
  //再次添加一个元素
  queue.add("dddd");
  System.out.println("再次添加元素后的队列：" + queue);
  //删除一个元素后，队列可以再多加一个元素
  queue.remove();
  //再次加入一个元素
  queue.add("eeee");
  System.out.println(queue);
 }
}

kucaozhuzhu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java-栈和队列
weixin_68993502的博客
08-10 180
栈和队列
Java的中的栈和队列
Lb_CsdnJava的博客
12-09 233
Java的中的栈和队列栈(Stack)基本概念栈的实现队列（Queue）基本概念队列的实现循环队列 栈(Stack) 基本概念 栈： 一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。 进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。 压栈： 栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。 出栈： ...
栈和队列(超详细Java实现)
qq_57735833的博客
07-30 9461
可以看到,先入栈的元素要等后入栈的元素出栈后才能出栈,栈中的元素总是遵循后进先出LIFO（Last In First Out）的原则。生活中的例子:JVM : Java虚拟机Java标准库中提供的栈 可以看到，Stack继承了Vector，Vector是动态的顺序表,与ArrayList类似,不同的是,Vector是线程安全的.实现的方法 输出结果: 2. 入栈(push) 3. 出栈(pop) 4.获取栈顶元素(peek) 5.获取元素个数(getSize) 6.判断栈是否为空(isEm
Java实现栈和队列
小小太空人的博客
09-29 623
栈和队列是两种特有的存储数据的结构，栈是后进先出的一种结构，队列是先进先出的一种结构。由于这种特有的结构，在选择底层存储方式也有差异。由于栈是后进先出的结构，其实就是尾删，尾增操作，如果用顺序表来存储，尾删、尾增时间复杂度则是O（1）。链表则需考虑链表的结构，如果是单链表，找尾的时间复杂度就是O（n）。如果是记录尾的双向链表，时间复杂度是O（1）。Java中也封装了这样的集合结构（Stack），用的就是顺序表。由于队列是先进先出的结构，其实就是头删，尾增操作。
【code】java栈和队列实现
不积跬步 无以至千里 不积小流 无以成江海
06-16 67
顺序栈的实现 import java.util.Arrays; public class SequenceStack&lt;T&gt; { private int DEFAULT_SIZE = 10; //保存数组的长度。 private int capacity; //定义当底层数组容量不够时，程序每次增加的数组长度 private int capacityIncrem...
java中栈和队列的实现和API用法
热门推荐
jayxu无捷之径的博客
06-17 1万+
在java中要实现栈和队列，需要用到java集合的相关知识，特别是Stack、LinkedList等相关集合类型。 一、栈的实现 栈的实现，有两个方法：一个是用java本身的集合类型Stack类型；另一个是借用LinkedList来间接实现Stack。 1.Stack实现 有关Stack的具体知识可以参考：http://www.cnblogs.com/skywang12345/p/3308
Java实现栈和队列面试题
09-03
4. **两个队列实现一个栈**： 使用两个队列，入栈操作将元素加入第一个队列，出栈时将第二个队列清空，将第一个队列的所有元素转移到第二个队列，此时第一个队列的最后一个元素就是栈顶元素，将其出队。 5. **设计...
如何使用两个栈实现队列Java
08-25
本篇文章将深入探讨如何使用两个栈来实现一个队列，并在Java语言中给出具体实现。 首先，我们要理解为何可以使用两个栈来模拟队列的行为。栈1作为辅助栈，用于临时存储数据，而栈2作为主栈，用于模拟队列的出队操作...
java中栈和队列的实现和API的用法(详解)
08-30
java中栈和队列的实现和API的用法详解 java中的栈和队列是两种常用的数据结构，分别用于实现后进先出（LIFO）和先进先出（FIFO）的数据存储和处理。以下是java中栈和队列的实现和API的用法详解。 一、栈的实现 在...
利用栈和队列实现迷宫
06-20
"利用栈和队列实现迷宫" 通过栈和队列两种不同的方法来实现迷宫问题。队列方法求出的迷宫路径是最短路径。迷宫问题是指在一个迷宫中找到从起点到终点的路径。这里我们使用栈和队列两种数据结构来解决这个问题。 栈...
Java模拟栈和队列数据结构的基本示例讲解
09-02
Java中的栈和队列是两种基本的数据结构，...总之，理解和掌握栈和队列的原理以及在Java中的实现方式，对于提升编程能力至关重要。通过实践和运用这些基本数据结构，可以解决很多复杂的问题，提高程序的效率和可读性。
Java中的栈和队列的代码实现
蹲茅坑逗蛆蛆
10-20 344
其实栈就是一个先进后出的属性 用一个数组代替这个栈 然后用一个top指示最高的位数 那样就能把一个简单的栈实现了public class mystack { private int[] arr;//数组代替栈 private int top;//top代替指针 //构造函数 public mystack(){ arr = new int[10]; top=-1; }
java数据结构——栈和队列的简单实现
Ez4Sterben的博客
03-18 638
1、栈 栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。 public class Stack { private int[] arr; private int flag = 0; public Stack(int
栈与队列（Java实现）
敲敲敲
01-27 1580
栈Stack 1.定义： 栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则 实际应用：常见的诸如撤销操作，网页后退操作，以及开发中程序的“调用栈”操作系统栈底层 2.三个常用方法： push方法——入栈 pop方法——出栈，即将栈顶元素删除并返该元素 peek方法——返回栈顶元素 3.实现基于数组的顺序栈 为什么选用数组呢，其实链表也可
栈和队列及JAVA实现
芒果就是没有盲的博客
11-21 1914
一.栈（LIFO)和队列(FIFO)也是经常使用的数据结构，我们经常用到的递归，实现时就是用栈保存相关的调用函数以及变量，线程在实现时也用栈来保存一些函数调用以及变量。栈其实是一种受限制的线性表，它对存储数据的规则是只能从一端进入数据，删除数据的时候也只能删除栈顶的数据，就是大家俗知的后进先出。队列和栈的最大不同就是队列是先进先出。 二.栈和队列的性质 栈：栈是只能进行一端插入删除操作的特殊线性...
Java中栈与队列的实现
weixin_45123763的博客
05-07 269
Java中栈的实现有两个方法：一个是用java本身的Stack类；另一个是借用LinkedList来间接实现Stack。 一、使用Java本身的Stack类： 1、Stack类的API设计： 构造方法：Stack() 成员方法： （1）入栈：push（） （2）出栈：pop（） 二、使用LinkedList实现： 1、构造方法：LinkedList< Integer > stack = new LinkedList< Integer >(); 2、成员方法： （1）入栈：addF
栈和队列（java实现）
L的博客
03-01 322
栈 栈是一种运算受限的线性表，是一种先进后出的数据结构，限定只能在一端进行插入和删除操作，允许操作的一端称为栈顶，不允许操作的称为栈底。 package com.wzc;/* *@date 2021/3/1 * @author wzc */ public class MyStack { //栈的底层我们用数组存储数据 int[] elements; public MyStack() { elements = new int[0]; } //压
方案-基于云架构的校园信息化建设方案.pdf
最新发布
07-29
方案-基于云架构的校园信息化建设方案.pdf
使用java栈实现队列
05-16
想要使用Java栈实现队列，可以使用两个栈来模拟队列的操作，一个栈作为输入栈，一个栈作为输出栈。具体实现如下： 1. 定义两个栈inputStack和outputStack，用于模拟队列的操作。 2. 入队操作时，将元素压入...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值