算法与数据结构系列之[队列]

最新推荐文章于 2021-08-18 21:40:16 发布
最新推荐文章于 2021-08-18 21:40:16 发布
阅读量114 收藏
点赞数 1
分类专栏： 算法与数据结构 文章标签： 队列 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yelang0/article/details/90901428
版权

在这里插入图片描述
上一篇介绍了栈这种数据结构，栈是从线性表的表尾进并从表尾出，即后进先出，先进后出，若是银行排队采用这种方式，估计先去的人都气死了。那么有没有先进先出，类似于银行排队这种方式的数据结构呢？答案是肯定的，队列就是这样先进先出(FIFO)的数据结构，只允许一端进行插入操作，另一端进行删除操作，允许插入的一端叫做队尾，删除操作的一端叫做队头。队列也有两种实现方式，可以采用动态数组实现，也可以使用单链表实现，其实现方式各有优缺点。但队列和栈不同之处在于采用动态数据实现时，入队从队尾进入，出队要在队首进行，即每次出队，队列中所有元素都要向前移动，以保证队列的队头，也就是下标为0的位置不为空，此时的时间复杂度是O(n),对性能有一定影响，所有需要用到循环队列来解决这一问题。关于循环队列的具体细节请参考数据结构的有关书籍，这里贴出代码，以供参考。
C语言代码：
1.Queue.c

#include <stdio.h>
#include <stdlib.h>

typedef int QElemType;
typedef int Status;

#define QUEUE_INIT_SIZE 100   //初始分配的存储空间大小
#define INCREMENT 10     //存储空间分配增量
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0

//循环队列
typedef struct {
    QElemType *data; //声明了一个名为data的长度不确定的数组，也叫“动态数组”
    int front;  //头指针
    int tail;  //尾指针
    int length; //维护一个队列分配的内存大小
}Queue;

/**
 * 初始化一个队列
 * @param Q
 * @return
 */
Status InitQueue(Queue *Q){
    Q->data = (QElemType *)malloc(QUEUE_INIT_SIZE * sizeof(QElemType));
    if(!Q->data)
        exit(-1);
    Q->front = 0;
    Q->tail =0;
    Q->length = QUEUE_INIT_SIZE;
    return OK;
}

/**
 * 返回队列的大小
 * @param Q
 * @return
 */
int GetQueueSize(Queue Q){
    return (Q.tail - Q.front + Q.length) % Q.length;
}

/**
 * 判断队列是否为空
 * @param Q
 * @return
 */
int IsQueueEmpty(Queue Q){
    if(Q.front == Q.tail)
        return TRUE;
    return FALSE;
}

/**
 * 循环队列入队
 * @param Q
 * @param e
 * @return
 */
Status EnQueue(Queue *Q,QElemType e){
    if((Q->tail+1) % Q->length == Q->front){ //队列已满，进行扩容
        Q->data = (QElemType *) realloc(Q->data,(Q->length + INCREMENT) * sizeof(QElemType));
        Q->length += INCREMENT;
    }
    if(!Q->data)  //分配内存失败
        exit(-1);
    Q->data[Q->tail] = e;
    Q->tail = (Q->tail + 1) % Q->length;
    return OK;
}

/**
 * 循环队列出队
 * @param Q
 * @param e
 * @return
 */
Status DeQueue(Queue *Q,QElemType *e){
    if(Q->front == Q->tail)  //队列为空
        return ERROR;
    *e = Q->data[Q->front];
    Q->front = (Q->front + 1) % Q->length;

    return OK;
}

/**
 * 遍历输出队列元素
 * @param queue
 */
void DisplayQueue(Queue queue){
    if(IsQueueEmpty(queue))
        printf("队列为空");
    for (int i = queue.front; i != queue.tail; i =(i+1) % queue.length) {
        printf("%d",queue.data[i]);
    }
    printf("\n");
}

//链表队列的实现
typedef struct QNode{
    QElemType data;
    struct QNode *next;
}QNode,*QueuePtr;

typedef struct {
    QueuePtr front,tail;
    int size;
}LinkQueue;

/**
 * 初始化一个链表队列
 * @param L
 * @return
 */
Status InitLinkQueue(LinkQueue *L){
    L->front = L->tail = (QueuePtr)malloc(sizeof(QNode));
    if(!L->front)
        exit(-1);
    L->front->next = NULL;
    L->size = 0;
    return OK;
}

/**
 * 返回链表队列的长度
 * @param linkQueue
 * @return
 */
int GetLinkQueueSize(LinkQueue linkQueue){
    return linkQueue.size;
}

/**
 * 判断链表队列是否为空
 * @param linkQueue
 * @return
 */
int IsLinkQueueEmpty(LinkQueue linkQueue){
    if(linkQueue.size == 0)
        return TRUE;
    return FALSE;
}

/**
 * 链表栈的入栈
 * @param Q
 * @param e
 * @return
 */
Status EnLinkQueue(LinkQueue *Q,QElemType e){
    QueuePtr  s = (QueuePtr)malloc(sizeof(QNode));
    if(!s)
        exit(-1);
    s->data = e;
    s->next = NULL;
    Q->tail->next = s;
    Q->tail = s;
    Q->size++;
    return OK;
}

/**
 * 链表队列的出队
 * @param Q
 * @param e
 * @return
 */
Status DeLinkQueue(LinkQueue *Q,QElemType *e){
    QueuePtr p;
    if(Q->front == Q->tail)  //队列为空
        return ERROR;
    p = Q->front->next;
    *e = p->data;
    Q->front->next = p->next;
    if(Q->tail == p)   //如果队列只有一个元素，删除一个元素后让队列的队尾指向链表头结点
        Q->tail = Q->front;
    free(p);
    Q->size--;
    return OK;
}

/**
 * 遍历输出链表队列的元素
 * @param linkQueue
 */
void DisplayLinkQueue(LinkQueue linkQueue){
    if(GetLinkQueueSize(linkQueue) == 0)
        printf("链表队列为空");
    QueuePtr q = linkQueue.front->next;
    while (q){
        printf("%d",q->data);
        q = q->next;
    }
    printf("\n");
}

2.Queue.h

typedef int QElemType;
typedef int Status;

//循环队列
typedef struct {
    QElemType *data; //声明了一个名为data的长度不确定的数组，也叫“动态数组”
    int front;  //头指针
    int tail;  //尾指针
    int length; //维护一个队列分配的内存大小
}Queue;

//初始化一个队列
Status InitQueue(Queue *Q);

//返回队列的大小
int GetQueueSize(Queue Q);

//判断队列是否为空
int IsQueueEmpty(Queue Q);

//循环队列入队
Status EnQueue(Queue *Q,QElemType e);

//循环队列出队
Status DeQueue(Queue *Q,QElemType *e);

//遍历输出队列元素
void DisplayQueue(Queue queue);

//链表队列的实现
typedef struct QNode{
    QElemType data;
    struct QNode *next;
}QNode,*QueuePtr;

typedef struct {
    QueuePtr front,tail;
    int size;
}LinkQueue;

//初始化一个链表队列
Status InitLinkQueue(LinkQueue *L);

//返回链表队列的长度
int GetLinkQueueSize(LinkQueue linkQueue);

//判断链表队列是否为空
int IsLinkQueueEmpty(LinkQueue linkQueue);

//链表栈的入栈
Status EnLinkQueue(LinkQueue *Q,QElemType e);

//链表队列的出队
Status DeLinkQueue(LinkQueue *Q,QElemType *e);

//遍历输出链表队列的元素
void DisplayLinkQueue(LinkQueue linkQueue);

3.main.c

//循环队列
    //初始化一个空的队列
    Queue queue;
    InitQueue(&queue);
    DisplayQueue(queue);
    //队列是否为空
    printf("%d",IsQueueEmpty(queue));
    printf("\n");
    //队列入队
    EnQueue(&queue,4);
    EnQueue(&queue,5);
    EnQueue(&queue,6);
    DisplayQueue(queue);
    //输出队列长度
    printf("%d",GetQueueSize(queue));
    printf("\n");
    //队列是否为空
    printf("%d",IsQueueEmpty(queue));
    printf("\n");
    //队列出队
    int num;
    int n = &num;
    DeQueue(&queue,n);
    DisplayQueue(queue);
    printf("%d",num);
    printf("\n");
    printf("---------------------------------------------");
    printf("\n");
    //链表队列
    //初始化一个链表队列
    LinkQueue linkQueue;
    InitLinkQueue(&linkQueue);
    DisplayLinkQueue(linkQueue);
    //链表队列入队
    EnLinkQueue(&linkQueue,7);
    EnLinkQueue(&linkQueue,8);
    EnLinkQueue(&linkQueue,9);
    DisplayLinkQueue(linkQueue);
    //输出链表队列长度
    printf("%d",GetLinkQueueSize(linkQueue));
    printf("\n");
    //链表队列是否为空
    int result = IsLinkQueueEmpty(linkQueue);
    if(result == 0)
        printf("false");
    if(result == 1)
        printf("true");
    printf("\n");
    //链表队列出队
    int element;
    int *e = &element;
    DeLinkQueue(&linkQueue,e);
    printf("%d",*e);
    printf("\n");
    DisplayLinkQueue(linkQueue);

4.运行结果

队列为空
1
456
3
0
56
4
---------------------------------------------
链表队列为空
789
3
false
7
89

java代码：
1.Queue.java

public interface Queue<E> {
    int getSize();
    boolean isEmpty();
    void enqueue(E e);
    E dequeue();
    E getFront();
}

2.ArrayQueue.java

/**
 * 用动态数组实现队列
 * @param <E>
 */
public class ArrayQueue<E> implements Queue<E> {

    private Array<E> array; //声明数组

    public ArrayQueue(int capacity){
        array = new Array<>(capacity);
    }

    public ArrayQueue(){
        array = new Array<>();
    }
    //队列大小
    @Override
    public int getSize() {
        return array.getSize();
    }
    //判断队列是否为空
    @Override
    public boolean isEmpty() {
        return array.isEmpty();
    }
    //入队
    @Override
    public void enqueue(E e) {
        array.add(e);
    }
    //出队
    @Override
    public E dequeue() {
        return array.remove(0);
    }
    //获取队列的首个元素
    @Override
    public E getFront() {
        return array.get(0);
    }
    //队列容量
    public int getCapacity(){
        return array.getCapacity();
    }

    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        res.append("Queue: ");
        res.append("front [");
        for (int i = 0; i <array.getSize() ; i++) {
            res.append(array.get(i));
            if(i != array.getSize()-1){
                res.append(",");
            }
        }
        res.append("] tail");
        return res.toString();
    }

    public static void main(String[] args) {
        ArrayQueue<Integer> arrayQueue = new ArrayQueue();
        for (int i = 0; i < 10; i++) {
            arrayQueue.enqueue(i);
            System.out.println(arrayQueue);

            if(i % 3 ==2){
                arrayQueue.dequeue();
                System.out.println(arrayQueue);
            }
        }
    }
}

3.LoopQueue.java

public class LoopQueue<E> implements Queue<E> {

    private int size;
    private E[] data;
    private int front,tail;

    public LoopQueue(int capacity){
        data = (E[]) new Object[capacity +1];
        front = 0;
        tail = 0;
        size = 0;
    }

    public LoopQueue(){
        this(10);
    }
    //获取循环队列容量
    public int getCapacity(){
        return data.length -1;
    }
    //获取循环队列大小
    @Override
    public int getSize() {
        return size;
    }
    //判断循环队列是否为空
    @Override
    public boolean isEmpty() {
        return front == tail;
    }
    //循环队列入队
    @Override
    public void enqueue(E e) {
        if((tail + 1) % data.length == front){
            resize(getCapacity() * 2);
        }
        data[tail] = e;
        tail = (tail + 1) % data.length;
        size++;
    }
    //循环队列出队
    @Override
    public E dequeue() {
        if(isEmpty()){
            throw new IllegalArgumentException("不能删除空的队列");
        }
        E ret = data[front];
        data[front] = null;
        front = (front + 1) % data.length;
        size--;
        if(size == getCapacity()/4 && getCapacity() /2 != 0){
            resize(getCapacity()/2);
        }
        return ret;
    }
    //获取循环队列的队首
    @Override
    public E getFront() {
        if(isEmpty()){
            throw new IllegalArgumentException("队列为空");
        }
        return data[front];
    }
    //扩容
    private void resize(int newCapacity){
        E[] newData = (E[]) new Object[newCapacity + 1];
        for (int i = 0; i < size; i++) {
            newData[i] = data[(front + i) % data.length];
        }
        data = newData;
        front = 0;
        tail = size;
    }

    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        res.append(String.format("Queue: size = %d , capacity = %d\n",size,getCapacity()));
        res.append("front [");
        for (int i = front; i != tail; i = (i + 1) % data.length) {
            res.append(data[i]);
            if((i + 1) % data.length != tail){
                res.append(",");
            }
        }
        res.append("] tail");
        return res.toString();
    }

    public static void main(String[] args) {
        LoopQueue<Integer> loopQueue = new LoopQueue<>();
        for (int i = 0; i < 11; i++) {
            loopQueue.enqueue(i);
            System.out.println(loopQueue);

            if(i % 3 == 2){
                loopQueue.dequeue();
                System.out.println(loopQueue);
            }
        }
    }
}

4.LinkedListQueue.java

/**
 * 用链表实现队列
 * @param <E>
 */
public class LinkedListQueue<E> implements Queue<E> {
    /**
     * 创建链表的内部类
     */
    private class  Node{
        public E e;
        public Node next;

        public Node(E e, Node next) {
            this.e = e;
            this.next = next;
        }

        public Node(E e) {
            this(e,null);
        }

        public Node(){
            this(null,null);
        }

        @Override
        public String toString() {
            return e.toString();
        }
    }

    private Node head,tail; //指向队首和队尾
    private int size; //队列大小

     //初始化一个空的队列,链表没有头结点
    public LinkedListQueue() {
        head = null;
        tail  = null;
        size = 0;
    }

    //返回队列的大小
    @Override
    public int getSize() {
        return size;
    }

    //判断队列是否为空
    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    //链表队列入队
    @Override
    public void enqueue(E e) {
        if(tail == null){
            tail = new Node(e);
            head = tail;
        }else {
            tail.next = new Node(e);
            tail = tail.next;
        }
        size++;
    }

    //链表队列出队
    @Override
    public E dequeue() {
        if(isEmpty()){
            throw new IllegalArgumentException("队列为空");
        }
        Node resNode = head;
        head = head.next;
        resNode.next = null;
        if(head == null){
            tail = null;
        }
        size--;
        return resNode.e;
    }

    //获得链表队列的首个元素
    @Override
    public E getFront() {
        if(isEmpty()){
            throw new IllegalArgumentException("队列为空");
        }
        return head.e;
    }

    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        res.append("Queue: ");
        Node cur = head;
        while (cur != null){
            res.append(cur + "->");
            cur = cur.next;
        }
        res.append("NULL");
        return res.toString();
    }
    public static void main(String[] args) {
        LinkedListQueue<Integer> linkedListQueue = new LinkedListQueue<>();
        for (int i = 1; i <= 10; i++) {
            linkedListQueue.enqueue(i);
            System.out.println(linkedListQueue);

            if(i % 3 ==2){
                linkedListQueue.dequeue();
                System.out.println(linkedListQueue);
            }
        }
    }
}
秦老厮
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Java数据结构与算法】队列
01-20
队列本身是个有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明如图，其中5是该队列的最大容量（只代表我这个图） 因为队列的输出，输入都是分别从前后端来处理的，因此需要两个变量（头部）及（尾部）...
数据结构与算法之美.zip
01-15
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
数据结构 队列的相关操作
weixin_30436891的博客
11-23 50
用单链表实现的队列，带一个头节点 实现简单的功能，程序中可能含有bug； 1 //this program used for basic operation about queue using list 2 // this list has a head node 3 // 4 //Author:zxJay 5 // 6 7 ...
《算法和数据结构》之队列
maohoo的博客
08-07 415
基本概念 队列（Queue）是一种先进先出（FIFO）的结构，类似于生活中的“独木桥”、“排队”等 对于Queue，核心api如下： 方法 描述 void enQueue(T s) 向队列中添加一个新的元素 T deQueue() 移除队列中最早添加的元素 boolean isEmpty() 队列是否为空 int size(...
数据结构与算法（栈和队列）
八归少年
01-11 4165
首语 历经一个月的时间，自己终于搭建完成了个人网站，还在持续优化中，网站采用halo博客系统，功能非常强大！欢迎大家来我的网站逛逛。有什么建议可以留言！ 网站地址：http://www.yanghujun.com 接下来我们开始第二节的数据结构学习，栈和队列。 栈 栈是限定仅在表尾进行插入和删除操作的线性表。 允许插入和删除的一端称为栈顶（top），另一端称为栈底（bottom），不含任...
数据结构与算法之队列
努力让自己发光，对的人才能迎着光而来
08-18 1万+
队列概念 队列的操作
数据结构与算法学习笔记
热门推荐
ityqing的博客
09-25 33万+
本文是王争老师的《算法与数据结构之美》的学习笔记，详细内容请看王争的专栏。有不懂的地方指出来，我做修改。 数据结构与算法思维导图 数据结构指的是“一组数据的存储结构”，算法指的是“操作数据的一组方法”。 数据结构是为算法服务的，算法是要作用再特定的数据结构上的。 最常用的数据结构预算法: 数据结构：数组、链表、栈、队列、散列表、二叉树‘、堆、跳表、图、Tire树 算法： 递归...
Java数据结构与算法02——队列
12-21
标签：Java 数据结构 算法 作者 ： Maxchen 版本 ： V1.0.0 日期 ： 2020/3/29 目录1.队列的概念2.数组模拟队列3.队列运行测试 1.队列的概念 队列同样是一种特殊的线性表，其插入和删除的操作分别在表的两端进行，...
算法与数据结构.zip
最新发布
01-15
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
常用算法与数据结构.zip
01-14
算法与数据结构涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）以及集合和...
算法与数据结构系列之[优先队列]
yelang0的博客
07-09 1457
前面我们介绍了队列这种数据结构，不过我们在前面所介绍的队列只是一种普通的队列，即元素先进先出，其实队列还可以分优先级，优先级高的元素先出，比如操作系统的调度，会将优先级高的任务先调度执行，这种队列就叫做优先队列。 那么优先队列底层该如何实现呢？ 1.优先队列可以使用普通的线性结构，比如动态数组，入队时的时间复杂度为O(1),出队时需要遍历元素，找到优先级最大的元素出队，时间复杂度为O(n)。 2....
算法与数据结构系列之[哈希表]
yelang0的博客
07-09 1013
前言 前面我们介绍线性表的时候，如果要查找某个元素，比如key,就需要从表头开始，逐个比较记录a[i]和key的值是相等还是不相等，知道有相等才算查找成功，返回i。那么我们有没有一种方法不用逐个比较就能查找到要查询的元素呢？答案是肯定的，我们可以通过关键字key得到要查找记录的内存位置，这就是我们这篇要介绍的哈希表，其实哈希表算是线性存储结构的范畴，因为哈希表用到数组作为存储结构。 1.什么是哈希...
算法与数据结构系列之[平衡二叉树-AVL树-下]
yelang0的博客
07-09 566
上篇介绍了AVL树的概述，这篇把AVL树的java代码实现贴出来 public class AVLTree<K extends Comparable<K>, V> { private class Node{ public K key; public V value; public Node left, right; ...
算法与数据结构系列之[平衡二叉树-AVL树-上]
yelang0的博客
07-09 531
1.问题概述 我们在介绍二分搜索树的时候提到时间复杂度为O(logn),但是这并不是绝对的，有些时候树可能退化为链表，时间复杂度回到O(n)级别，所以为了性能考虑，应尽量避免这种退化，这就用到了平衡树。 2.什么是平衡二叉树 平衡二叉树的定义是，对于任意一个节点，左子树和右子树的高度差不能超过1，且平衡二叉树的高度和节点的数量之间的关系一是O(logn)的。我们前面介绍的满二叉树、完全二叉树和线...
算法与数据结构系列之[树-概念]
yelang0的博客
06-08 468
在前面几篇介绍了线性数据结构，那么接下来几篇将会详细介绍下树这种数据结构。有了数组和链表等线性数据结构存储数据已经很方便了，那么为什么还需要树这种数据结构呢？ 当然是相较于数组和链表，树具有自己独特的有点，正好能够弥补数组和链表的缺点，我们先看下数组和链表的优缺点，也算是对前面内容的一个总结。 数组通过下标方式访问元素，查询速度快，对于有序数组，还可以利用二分查找法提高检索速度。但是数组在查询某...
算法与数据结构系列之[二叉树-上]
yelang0的博客
07-09 291
上篇从整体上介绍了树的一些基本概念，编程中我们用到的都是具体的树结构，比如二叉树。接下来我们用上、中、下三篇详细介绍二叉树，其中上篇为二叉树的理论部分，中篇为二叉树的C语言代码实现，下篇为二叉树的Java代码实现。 前言 现实中树的种类有很多种，数据结构中树的种类也不是单一的，有二叉树，B树，B+树，红黑树等，二叉树应该说是最常用的一种树形结构，这篇就重点介绍下二叉树。 一、二叉树的定义： 二叉树...
算法与数据结构系列之[字典树-Trie]
yelang0的博客
07-09 278
1.什么是字典树-Trie 百科解释：(之所以引用百度百科的解释，是因为百科的解释概括性已经很好，也很全面，只需要少许补充即可) 字典树又称单词查找树，Trie树，是一种树形结构，是一种哈希树的变种。典型应用是用于统计，排序和保存大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：利用字符串的公共前缀来减少查询时间，最大限度地减少无谓的字符串比较，查询效率比哈希树...
算法与数据结构系列之[图-概念]
yelang0的博客
07-09 259
前言 前面我们介绍了线性表和树这两大类数据结构，线性表局限于一个直接前驱和一个直接后继，树也只能有一个直接前驱也就是父节点，当我们需要表示多对多的关系时就需要用到图这种数据结构，比如微博，微信互相关注，互加好友的社交关系就用图来表示。 1.概述 图(Graph)是一种数据结构，由结点和边组成，通常表示为G(V,E),其中G表示一个图，V是图G中结点的集合，结点也称顶点，可以具有零个或多个相邻元素，...
算法与数据结构系列之[并查集-下]
yelang0的博客
07-09 259
接着上篇介绍并查集的优化方法 3.路径压缩 上一篇介绍了基于rank的优化，但是依然有一定的问题需要解决，因为当我们的数据量越来越大时，树的高度可能也会随之变大，数据量小的时候影响不大，但当数据量很大时，树的高度比较高，查询数据就会变慢了，所以我们有必要通过减小树的高度而不破坏原先的连接关系的方法来解决以上问题。我们可以在每次查询时将树的高度缩减，这就是路径压缩。 如上图，三个图表示的结果是相同...
数据结构与算法 - 队列
09-12
队列（Queue）是一种先进先出（FIFO）的数据结构，类似于现实生活中排队的概念。它有两个基本操作：入队（enqueue）和出队（dequeue）。 入队操作将元素添加到队列的末尾，出队操作则从队列的头部移除元素并返回它...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值