day19——三、队列

已于 2024-07-23 19:37:47 修改
阅读量322 收藏 2
点赞数 10
文章标签： c#
于 2024-07-23 18:54:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_69277585/article/details/140643489
版权

3.1 队列介绍

1> 队列也是操作受限的线性表：所有操作只能在端点处进行，其删除和插入必须在不同端进行

2> 允许插入操作的一端称为队尾，允许删除操作的一端称为队头

3> 特点：先进先出（FIFO）

4> 分类：

顺序存储的队列称为顺序队列

链式存储的队列，称为链式队列

3.2 顺序队列

1> 使用一片连续存储的空间存储队列，并且给定两个变量，分别记录队头和队尾下标

2> 普通顺序队列使用中，存在“假溢满”现象

假溢满：队列中明明还有存储空间，但是由于队尾已经达到了数组的最大下标，不能在继续入队元素了

3> 为了解决“假溢满”现象，我们引入了循环顺序队列

3.3 循环顺序队列

1> 循环顺序队列：

通过相关操作，当对头或队尾达到数组最大下标时，可以返回到下标为0的位置

2> 结构体类型：

一个数组存储队列，两个变量分别存储队头和队尾的下标

注意：需要人为浪费一个存储空间，用于判满

#define MAX 8          //队列最大长度
typedef int datatype;   //数据元素类型
//定义队列类型
typedef struct
{
    datatype data[MAX];   //存储队列的容器
    int front;          //记录队头下标
    int tail;           //记录队尾下标
}SeqQueue, *SeqQueuePtr;

3> 创建队列

//创建队列
SeqQueuePtr queue_create()
{
    //在堆区申请一个队列的大小
    SeqQueuePtr Q =(SeqQueuePtr)malloc(sizeof(SeqQueue));
    if(NULL==Q)
    {
        printf("创建失败\n");
        return NULL;
    }

    //初始化
    bzero(Q->data, sizeof(Q->data));  //初始化数组
    Q->front = Q->tail = 0;          //队列为空

    printf("队列创建成功\n");
    return Q;
}

4> 判空判满

//队列判空
int queue_empty(SeqQueuePtr Q)
{
    return Q->front == Q->tail;
}

//队列判满
int queue_full(SeqQueuePtr Q)
{
    return (Q->tail+1)%MAX == Q->front;
}

5> 入队：将数据放入队尾所在位置

//入队
void queue_push(SeqQueuePtr Q, datatype e)
{
    //判断逻辑
    if(NULL==Q || queue_full(Q))
    {
        printf("入队失败\n");
        return ;
    }

    //入队逻辑
    Q->data[Q->tail] = e;

    //队列变化：队尾后移
    Q->tail = (Q->tail+1)%MAX;

    printf("入队成功\n");
}

6> 遍历队

//遍历队列
void queue_show(SeqQueuePtr Q)
{
    //判断逻辑
    if(NULL==Q || queue_empty(Q))
    {
        printf("遍历失败\n");
        return ;
    }

    //遍历逻辑
    printf("从队头到队尾元素分别是：");
    for(int i=Q->front; i!=Q->tail; i=(i+1)%MAX)
    {
        printf("%d\t", Q->data[i]);
    }
    printf("\n");
}

7> 出队

//出队
void queue_pop(SeqQueuePtr Q)
{
    //判断逻辑
    if(NULL==Q || queue_empty(Q))
    {
        printf("出队失败\n");
        return;
    }

    //出队逻辑
    printf("%d出队成功\n", Q->data[Q->front]);

    //队头后移
    Q->front = (Q->front+1)%MAX;

}

8> 求队列的大小：只用队头和队尾完成

//求队列的大小
int queue_size(SeqQueuePtr Q)
{
    //在不使用循环的情况下求大小
    //判断逻辑
    if(NULL == Q)
    {
        printf("失败\n");
        return -1;
    }

    return (Q->tail-Q->front+MAX)%MAX;    //核心语句
}

9> 销毁队列

//销毁队列
void queue_destroy(SeqQueuePtr Q)
{
    if(NULL != Q)
    {
        free(Q);
        Q = NULL;
    }

    printf("销毁成功\n");
}

3.4 所有代码

1.c

#include"1.h"

int main(int argc, const char *argv[])
{
    //调用创建队列函数
    SeqQueuePtr Q = queue_create();
    if(NULL == Q)
    {
        return -1;
    }
    
    //调用入队函数
    queue_push(Q, 520);
    queue_push(Q, 1314);
    queue_push(Q, 666);
    queue_push(Q, 999);

    //调用遍历函数
    queue_show(Q);

    //调用出队函数
    queue_pop(Q);
    queue_pop(Q);
    queue_pop(Q);
    queue_pop(Q);
    queue_pop(Q);

    queue_show(Q);

    //销毁队列
    queue_destroy(Q);
    Q = NULL;




    
    return 0;
}

2.c

#include"1.h"

//创建队列
SeqQueuePtr queue_create()
{
    //在堆区申请一个队列的大小
    SeqQueuePtr Q =(SeqQueuePtr)malloc(sizeof(SeqQueue));
    if(NULL==Q)
    {
        printf("创建失败\n");
        return NULL;
    }

    //初始化
    bzero(Q->data, sizeof(Q->data));  //初始化数组
    Q->front = Q->tail = 0;          //队列为空

    printf("队列创建成功\n");
    return Q;
}

//队列判空
int queue_empty(SeqQueuePtr Q)
{
    return Q->front == Q->tail;
}

//队列判满
int queue_full(SeqQueuePtr Q)
{
    return (Q->tail+1)%MAX == Q->front;
}

//入队
void queue_push(SeqQueuePtr Q, datatype e)
{
    //判断逻辑
    if(NULL==Q || queue_full(Q))
    {
        printf("入队失败\n");
        return ;
    }

    //入队逻辑
    Q->data[Q->tail] = e;

    //队列变化：队尾后移
    Q->tail = (Q->tail+1)%MAX;

    printf("入队成功\n");
}

//遍历队列
void queue_show(SeqQueuePtr Q)
{
    //判断逻辑
    if(NULL==Q || queue_empty(Q))
    {
        printf("遍历失败\n");
        return ;
    }

    //遍历逻辑
    printf("从队头到队尾元素分别是：");
    for(int i=Q->front; i!=Q->tail; i=(i+1)%MAX)
    {
        printf("%d\t", Q->data[i]);
    }
    printf("\n");
}

//出队
void queue_pop(SeqQueuePtr Q)
{
    //判断逻辑
    if(NULL==Q || queue_empty(Q))
    {
        printf("出队失败\n");
        return;
    }

    //出队逻辑
    printf("%d出队成功\n", Q->data[Q->front]);

    //队头后移
    Q->front = (Q->front+1)%MAX;

}

//求队列的大小
int queue_size(SeqQueuePtr Q)
{
    //在不使用循环的情况下求大小
    //判断逻辑
    if(NULL == Q)
    {
        printf("失败\n");
        return -1;
    }

    return (Q->tail-Q->front+MAX)%MAX;    //核心语句
}

//销毁队列
void queue_destroy(SeqQueuePtr Q)
{
    if(NULL != Q)
    {
        free(Q);
        Q = NULL;
    }

    printf("销毁成功\n");
}

1.h

#ifndef LOOPSEQQUEUE_H
#define LOOPSEQQUEUE_H

#include<myhead.h>

#define MAX 8          //队列最大长度
typedef int datatype;   //数据元素类型
//定义队列类型
typedef struct
{
    datatype data[MAX];   //存储队列的容器
    int front;          //记录队头下标
    int tail;           //记录队尾下标
}SeqQueue, *SeqQueuePtr;

//创建队列
SeqQueuePtr queue_create();

//队列判空
int queue_empty(SeqQueuePtr Q);

//队列判满
int queue_full(SeqQueuePtr Q);

//入队
void queue_push(SeqQueuePtr Q, datatype e);

//遍历队列
void queue_show(SeqQueuePtr Q);

//出队
void queue_pop(SeqQueuePtr Q);

//求队列的大小
int queue_size(SeqQueuePtr Q);

//销毁队列
void queue_destroy(SeqQueuePtr Q);

#endif

3.5 链式队列

1> 链式存储的队列称为链式队列

2> 实现原理：

单向链表头插尾删实现：链表的头部就是队尾，链表的尾部就是队头

单向链表头删尾插实现：链表的头部就是队头，链表的尾部就是队尾

但是：上述操作中，都要用到链表尾部节点，都需要遍历整个链表完成，效率较低

此时，我们可以引入尾指针的概念，专门指向最后一个节点的指针。

3> 将一个头指针和一个尾指针封装成一个队列

4> 队列类型

//定义数据元素类型
typedef int datatype;

//定义结点类型
typedef struct Node
{
    union
    {
        datatype data;  //数据域
        int len;      //长度
    };

    struct Node *next;   //指针域
}Node, *NodePtr;

//定义队列类型
typedef struct 
{
    NodePtr head;    //头指针
    NodePtr tail;    //尾指针
}Queue, *QueuePtr;

5> 创建队列

注意：先创建出队列、然后创建链表、将队列的两个指针指向链表

//创建队列
QueuePtr queue_create()
{
    //堆区申请一个队列的空间
    QueuePtr Q = (QueuePtr)malloc(sizeof(Queue));
    if(NULL == Q)
    {
        printf("创建失败\n");
        return NULL;
    }

    //此时 Q->head 和Q->tail是两个野指针

    //创建一个链表
    Q->head = (NodePtr)malloc(sizeof(Node));
    if(Q->head == NULL)
    {
        printf("创建失败\n");
        free(Q);     //释放队列空间
        return NULL;
    }
    //给头结点初始化
    Q->head->len = 0;
    Q->head->next = NULL;
    
    //将两个指针指向头结点
    Q->tail = Q->head;

    printf("创建成功\n");
    return Q;

}

6> 队列判空

只需要队头和队尾都指向头结点即可

//判空
int queue_empty(QueuePtr Q)
{
    return Q->head == Q->tail;
}

7> 入队

//入队
void queue_push(QueuePtr Q, datatype e)
{
    //判断逻辑
    if(NULL==Q)
    {
        printf("入队失败\n");
        return;
    }

    //申请结点封装数据
    NodePtr p = (NodePtr)malloc(sizeof(Node));
    if(NULL==p)
    {
        printf("入队失败\n");
        return;
    }
    //初始化
    p->data = e;
    p->next = NULL;

    //尾插
    Q->tail->next = p;    //将结点连接到链表上

    //更新尾指针
    Q->tail = p;

    //表长变化
    Q->head->len++;

    printf("入队成功\n");
}

8> 遍历队

//遍历队列
void queue_show(QueuePtr Q)
{
    //判断逻辑
    if(NULL==Q || queue_empty(Q))
    {
        printf("遍历失败\n");
        return ;
    }

    //定义遍历指针，从第一个结点出发
    NodePtr q = Q->head->next;
    while(q!=NULL)
    {
        //只要结点不为空，就输出数据域
        printf("%d\t", q->data);

        q = q->next;     //向后遍历
    }
    printf("\n");

}

9> 出队

出队时，需要注意，如果所有节点全部出队，则需要将尾指针重新指向头结点

//出队
void queue_pop(QueuePtr Q)
{
    //判断逻辑
    if(NULL==Q || queue_empty(Q))
    {
        printf("出队失败\n");
        return ;
    }

    //出队：头删
    NodePtr p = Q->head->next;    //标记
    Q->head->next = p->next;      //孤立

    printf("%d出队成功\n", p->data);
    free(p);                      //删除
    p = NULL;

    //判断是否已经全部删除
    if(Q->head->next == NULL)
    {
        //尾指针重新指向头结点
        Q->tail = Q->head;
    }


    //表长变化
    Q->head->len--;

}

10> 销毁队伍

//销毁队列
void queue_destroy(QueuePtr Q)
{
    //判断逻辑
    if(NULL==Q)
    {
        return;
    }

    //释放所有的结点
    while(!queue_empty(Q))
    {
        queue_pop(Q);      //不断将结点出队
    }
    
    //释放头结点
    free(Q->head);
    Q->head=Q->tail = NULL;    //防止野指针

    //释放队列空间
    free(Q);
    Q = NULL;
    printf("释放成功\n");
}

11> 求队列长度

//求队列长度
int queue_size(QueuePtr Q)
{
    //判断逻辑
    if(NULL==Q)
    {
        return -1;
    }

    return Q->head->len;

}

3.6 所有代码

1.c

#include"1.h"

//创建队列
QueuePtr queue_create()
{
    //堆区申请一个队列的空间
    QueuePtr Q = (QueuePtr)malloc(sizeof(Queue));
    if(NULL == Q)
    {
        printf("创建失败\n");
        return NULL;
    }

    //此时 Q->head 和Q->tail是两个野指针

    //创建一个链表
    Q->head = (NodePtr)malloc(sizeof(Node));
    if(Q->head == NULL)
    {
        printf("创建失败\n");
        free(Q);     //释放队列空间
        return NULL;
    }
    //给头结点初始化
    Q->head->len = 0;
    Q->head->next = NULL;
    
    //将两个指针指向头结点
    Q->tail = Q->head;

    printf("创建成功\n");
    return Q;

}

//判空
int queue_empty(QueuePtr Q)
{
    return Q->head == Q->tail;
}

//入队
void queue_push(QueuePtr Q, datatype e)
{
    //判断逻辑
    if(NULL==Q)
    {
        printf("入队失败\n");
        return;
    }

    //申请结点封装数据
    NodePtr p = (NodePtr)malloc(sizeof(Node));
    if(NULL==p)
    {
        printf("入队失败\n");
        return;
    }
    //初始化
    p->data = e;
    p->next = NULL;

    //尾插
    Q->tail->next = p;    //将结点连接到链表上

    //更新尾指针
    Q->tail = p;

    //表长变化
    Q->head->len++;

    printf("入队成功\n");
}

//遍历队列
void queue_show(QueuePtr Q)
{
    //判断逻辑
    if(NULL==Q || queue_empty(Q))
    {
        printf("遍历失败\n");
        return ;
    }

    //定义遍历指针，从第一个结点出发
    NodePtr q = Q->head->next;
    while(q!=NULL)
    {
        //只要结点不为空，就输出数据域
        printf("%d\t", q->data);

        q = q->next;     //向后遍历
    }
    printf("\n");

}

//出队
void queue_pop(QueuePtr Q)
{
    //判断逻辑
    if(NULL==Q || queue_empty(Q))
    {
        printf("出队失败\n");
        return ;
    }

    //出队：头删
    NodePtr p = Q->head->next;    //标记
    Q->head->next = p->next;      //孤立

    printf("%d出队成功\n", p->data);
    free(p);                      //删除
    p = NULL;

    //判断是否已经全部删除
    if(Q->head->next == NULL)
    {
        //尾指针重新指向头结点
        Q->tail = Q->head;
    }


    //表长变化
    Q->head->len--;

}

//求队列长度
int queue_size(QueuePtr Q)
{
    //判断逻辑
    if(NULL==Q)
    {
        return -1;
    }

    return Q->head->len;

}

//销毁队列
void queue_destroy(QueuePtr Q)
{
    //判断逻辑
    if(NULL==Q)
    {
        return;
    }

    //释放所有的结点
    while(!queue_empty(Q))
    {
        queue_pop(Q);      //不断将结点出队
    }
    
    //释放头结点
    free(Q->head);
    Q->head=Q->tail = NULL;    //防止野指针

    //释放队列空间
    free(Q);
    Q = NULL;
    printf("释放成功\n");
}

2.c

#include"1.h"

int main(int argc, const char *argv[])
{
    //调用创建函数
    QueuePtr Q = queue_create();
    if(NULL==Q)
    {
        return -1;
    }

    //调用入队函数
    queue_push(Q, 111);
    queue_push(Q, 222);
    queue_push(Q, 333);
    queue_push(Q, 444);

    //调用遍历函数
    queue_show(Q);

    //调用出队函数
    queue_pop(Q);
    queue_pop(Q);
    
    //释放队列空间
    queue_destroy(Q);
    Q = NULL;


    
    return 0;
}

1.h

#ifndef LOOPLINKQUEUE_H
#define LOOPLINKQUEUE_H
#include<myhead.h>
//定义数据元素类型
typedef int datatype;

//定义结点类型
typedef struct Node
{
    union
    {
        datatype data;  //数据域
        int len;      //长度
    };

    struct Node *next;   //指针域
}Node, *NodePtr;

//定义队列类型
typedef struct 
{
    NodePtr head;    //头指针
    NodePtr tail;    //尾指针
}Queue, *QueuePtr;

//创建队列
QueuePtr queue_create();


//判空
int queue_empty(QueuePtr Q);

//入队
void queue_push(QueuePtr Q, datatype e);

//遍历队列
void queue_show(QueuePtr Q);

//出队
void queue_pop(QueuePtr Q);

//求队列长度
int queue_size(QueuePtr Q);

//销毁队列
void queue_destroy(QueuePtr Q);





#endif

初夏怡情
关注
  • 10
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java岗大厂面试百日冲刺 - 日积月累，每日三题【Day19】—— 集合框架3
陈哈哈的菜园子
07-05 1万+
百日闭关修炼，每日三道高频面试题。一起冲进大厂！看什么看？快上车！
day26——多进程编程
m0_69277585的博客
08-01 751
程序员写程序时，一个程序可能由多个任务组成，如果使用的是单进程，或单任务，那么当该任务执行阻塞时，其他任务就无法执行，必须等到该任务解除阻塞后，才能去执行其他任务。多进程或多线程，可以解决同一个程序中多个任务并发执行的情况。
Day19——图的广度优先遍历、深度优先遍历
Z__XY_的博客
04-18 239
图的广度优先遍历：从一个结点出发，优先遍历与之相连的结点，然后再广度遍历第一个与该结点相连的结点。 需要考虑的情况： 因为结点之间是多对多的关系，所以有可能访问过的结点会再次被访问，因此需要标识已经访问过的结点； 图有可能是非连通图，所以从一个结点出发并不能访问所有结点，因此需要加一个循环来判断是否所有结点已被访问； 不难从图中观察到，结点的遍历是有先进先出的特点，所以选用队列来进行存储结点。 广度优先遍历代码： /** * ********************* * @Title:
day29——多线程编程补充
m0_69277585的博客
08-05 623
1> 对于多个线程之间通信，我们可以使用临界资源来完成，通过一个线程任务对临界资源进行修改，另一个线程也可以使用已经修改过的临界资源，但是要注意使用同步互斥机制完成对临界资源的保护2> 多个进程之间能否使用全局变量来进行进程间通信？答：不能，多个进程之间的用户空间是相互独立的，每个进程的全局变量是各个进程独立拥有的，更改一个进程的全局变量，另一个进程不会受到影响，故而不能使用全局变量来完成通信3> 有同学说：使用文件来完成进程间通信？
寒假每日一题打卡day19——Acwing 482. 合唱队形
JohnnyLin
01-27 122
【题目描述】 【思路】 即找到一个k，使得k左边从k到1严格递减，右边从k到n也严格递减。实际上就是两个最长上升子序列问题。 Acwing 482. 合唱队形 import java.io.*; import java.lang.Math; public class Main{ static int N = 110; public static void main(String args[]) throws Exception{ BufferedReader bf = ne
ActiveMQ——Day04
风间琉璃の博客
10-22 324
15. ActiveMQ传输协议 在ActiveMQ的配置文件中默认支持五种传输协议，分别是：1. openwire(tcp) 2.amqp 3.stomp 4.mqtt 5.ws。在更改协议时，必须保证ActiveMQ没有运行。 15.1 Tcp： TCP传输允许客户端使用TCP套接字段，远程连接到ActiveMQ代理，这些配置了JMS的客户端的连接URL字符串或在代理的传输连接器URI上调整客户端上的底层TCP传输。 TCP是默认的broker配置，TCP的Client监听端口61616，在网络传输协议
day41——多进程的消息队列、消息队列pipe
weixin_34358092的博客
12-16 55
多进程的消息队列 消息队列指的是消息在传输过程中保存消息的容器 消息队列最经典的用法是消费者和生产者之间通过消息管道来传递消息。消费者和和生产者是不同的进程，生产者往管道中写消息，消费者从管道中读消息 multiprocessing模块提供了Queue类 和 Pipe函数 实现消息队列 1. Queue 用法： In [1]: import multiproc...
ACwing算法备战蓝桥杯——Day12——BFS
weixin_73569934的博客
03-01 235
这些题都是通过距离数组储存来对层次进行计数和判断是否遍历过!暴力枚举每一个状态，时间复杂度高。就是树的层序遍历，利用队列维护。
day42——queue模块
weixin_34279579的博客
12-19 56
Python提供了Queue模块来专门实现消息队列Queue对象Queue对象实现一个fifo队列（其他的还有lifo、priority队列，这里不再介绍）。queue只有maxsize一个构造参数，用来指定队列容量，指定为0的时候代表容量无限。主要有以下成员函数：Queue.qsize()：返回消息队列的当前空间。返回的值不一定可靠。Queue.empty()：判断消息队列是否为空，返回True...
算法练习day8——190326（猫狗队列、转圈打印矩阵、旋转正方形矩阵、反转单向双向链表、数N的加法组合）
Zhxin606a的博客
03-26 273
1.猫狗队列 【题目】 宠物、 狗和猫的类如下： public class Pet { private String type; public Pet(String type) { this.type = type; } public String getPetType() { return this.type; } }...
Java选择题日常记录——Day16—Day30
Terio的博客
03-24 5565
Java选择题刷题记录Day16Q1题解Q2题解Q3题解Q4题解 Day16 Q1 下面有关 JAVA 异常类的描述,说法正确的有() 异常的继承结构:基类为 Throwable,Error 和 Exception 。实现 Throwable, RuntimeException 和 IOException 等继承 Exception 非 RuntimeException 一般是外部错误(不考虑Error的情况下),其可以在当前类被 try{}catch 语句块所捕获 Error 类体系描述了 Java 运
常见的测试面试问题之应届生——day1
qq_51359091的博客
06-08 824
常见测试面试问题
[单调队列] day.1
skysys的研究小屋
07-12 801
单调队列的操作举例不妨用一个问题来说明单调队列的作用和操作： 不断地向缓存数组里读入元素，也不时地去掉最老的元素，不定期的询问当前缓存数组里的最小的元素。 最直接的方法：普通队列实现缓存数组。 进队出队都是O(1)，一次查询需要遍历当前队列的所有元素，故O(n)。用堆实现缓存数组堆顶始终是最小元素，故查询是O(1)。 而进队出队，都要调整堆，是O(log(n))。RMQ的方法RMQ即Rang
Day19 2021.4.5 JVM入门
hc1235的博客
04-05 1159
Day19 2021.4.5 JVM入门 请你谈谈你对JVM的理解？java8虚拟机和之前的变化更新？ 什么事OOM，什么事栈溢出StackOverFlowError？怎么分析 JVM的常用调优参数有哪些？ 内存快照如何抓取，怎么分析Dump文件？知道吗？ 谈谈JVM中，类加载器你的认识 1.JVM的位置 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oNfDxLE2-1617606415829)(C:\Users\asus\AppData\Roaming\Typora\
EmguCV学习笔记 VB.Net 8.2 分水岭法 watershed
最新发布
UruseiBest 的技术专栏
08-30 1264
EmguCV是一个基于OpenCV的开源免费的跨平台计算机视觉库,它向C#和VB.NET开发者提供了OpenCV库的大部分功能。教程配套文件及相关说明获得pdf教程和代码。
C#桌面开发之巅：Windows Forms与WPF深度解析
2401_85761762的博客
08-25 2176
C#作为.NET框架的核心语言之一，提供了强大的桌面应用程序开发能力。Windows Forms和WPF（Windows Presentation Foundation）是两个主要的UI框架，用于构建交互式桌面应用程序。本文将详细介绍如何在C#中使用Windows Forms和WPF进行桌面应用程序开发，包括界面设计、事件处理、数据绑定等关键技术，并提供实际代码示例。桌面应用程序与Web应用程序相比，提供了更丰富的用户交互体验和系统资源访问能力。探讨在WPF中创建自定义控件和使用动画来增强用户界面。
python自述1
Re_view的博客
08-28 989
python自述1
C#实现文件的上传
qq_25699299的博客
08-28 523
确保你的API端点能够处理multipart/form-data类型的请求，并且你有权限上传文件到指定的位置。应该是你的文件上传API的URL，是你要上传的文件的本地路径。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值