【上机实验】03：循环队列与扩容

已于 2023-04-14 11:04:27 修改
阅读量1.2k 收藏 11
点赞数 2
分类专栏： 数据结构与算法实现C 文章标签： 数据结构
于 2022-04-21 19:09:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49167174/article/details/124329190
版权

循环队列与扩容

目录

1.顺序队列操作
#include<stdio.h>
#include<stdlib.h>
#include<time.h>

typedef struct{
    int *data;
    int front, rear;
    int length;
}SqQueue;

//1.队列初始化
SqQueue *InitQueue(int n){
    SqQueue *sq = (SqQueue *)malloc(sizeof(SqQueue));
    sq->data = (int *)malloc(sizeof(int) * n);
    sq->length = n;
    sq->front = sq->rear = 0;
    return sq;
}

//2.队列销毁
void DestroyQueue(SqQueue *sq){
    if (sq == NULL) return;
    free(sq->data);
    free(sq);
    return;
}

//3.队列判空
int QueueEmpty(SqQueue *sq){
    return sq->front == sq->rear;
}

//4.获取队列队首元素
int GetHead(SqQueue *sq){
    if(sq->front != sq->rear) return sq->data[sq->front];
}

//5.队列入队
int Push(SqQueue *sq, int val){
    if(sq == NULL) return 0;
    if(sq->rear == sq->length) return 0;
    sq->data[sq->rear] = val;
    sq->rear++;
    return 1;
}

//6.队列出队
int Pop(SqQueue *sq){
    if(sq == NULL) return 0;
    if(QueueEmpty(sq)) return 0;
    sq->front += 1;
    return 1;
}

void print(SqQueue *sq){
    printf("Queue : [");
    for(int i = sq->front; i < sq->rear; ++i){
        i != sq->front && printf(", ");
        printf("%d", sq->data[i]);
    }
    printf("]\n");
    return ;
}

int main(){
    srand(time(0));
    #define MAX_OP 20
    SqQueue *sq = InitQueue(10);
    for(int i = 0; i < MAX_OP; ++i){
        int op = rand() % 4;
        int val = rand() % 100;
        switch(op){
            case 0:
            case 1:
            case 2:{
                printf("push %d to the Queue = %d\n", val, Push(sq, val));
            }break;
            case 3:{
                printf("pop %d from the Queue = ", GetHead(sq));
                printf("%d\n", Pop(sq));
            }break;
        }
        print(sq);
    }
    #undef MAX_OP
    DestroyQueue(sq);
    return 0;
}

普通队列存在假溢出现象，注意到最后5次push操作全部失败，但是queue队列中的元素却并没有达到设置的最大容量值10

在这里插入图片描述

2.循环顺序队列：

在这里插入图片描述

为了处理顺序队列的假溢出问题，

将普通队列修改为循环队列，程序中主要修改三个部分：

  • 对于SqQueue结构体：增加一个count变量用于记录循环队列中实际存储的元素个数
typedef struct{
    int *data;
    int front, rear;
    int length;//队列容量
    int count;//实际存储的元素个数
}SqQueue;
  • 对于push操作的修改：当尾指针达到队尾时，再添加元素将其重新调到队头
if(sq->rear == sq->length) sq->rear = 0;//尾指针置0
sq->count++;
  • 对于pop操作的修改：当头指针达到队尾时，再删除元素则将其重新调到队头
if(sq->front == sq->length) sq->front = 0;//头指针置0
sq->count--;

循环顺序队列的实现：

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

typedef struct{
    int *data;
    int front, rear;
    int length;
    int count;
}SqQueue;

//1.队列初始化
SqQueue *InitQueue(int n){
    SqQueue *sq = (SqQueue *)malloc(sizeof(SqQueue));
    sq->data = (int *)malloc(sizeof(int) * n);
    sq->length = n;
    sq->front = sq->rear = 0;
    sq->count = 0;
    return sq;
}

//2.队列销毁
void DestroyQueue(SqQueue *sq){
    if (sq == NULL) return;
    free(sq->data);
    free(sq);
    return;
}

//3.队列判空
int QueueEmpty(SqQueue *sq){
    return sq->count == 0;
}

//4.获取队列队首元素
int GetHead(SqQueue *sq){
    if(sq->front != sq->rear) return sq->data[sq->front];
}

//5.队列入队
int Push(SqQueue *sq, int val){
    if(sq == NULL) return 0;
    if(sq->count == sq->length) return 0;
    sq->data[sq->rear++] = val;
    if(sq->rear == sq->length) sq->rear = 0;//尾指针置0
    sq->count++;
    return 1;
}

//6.队列出队
int Pop(SqQueue *sq){
    if(sq == NULL) return 0;
    if(QueueEmpty(sq)) return 0;
    sq->front++;
    if(sq->front == sq->length) sq->front = 0;//头指针置0
    sq->count--;
    return 1;
}

void print(SqQueue *sq){
    printf("Queue(%d) : [", sq->count);
    for(int i = 0; i < sq->count; ++i){
        i && printf(", ");
        printf("%d", sq->data[(i + sq->front) % sq->length]);
    }
    printf("]\n");
    return ;
}

int main(){
    srand(time(0));
    #define MAX_OP 20
    SqQueue *sq = InitQueue(10);
    for(int i = 0; i < MAX_OP; ++i){
        int op = rand() % 4;
        int val = rand() % 100;
        switch(op){
            case 0:
            case 1:
            case 2:{
                printf("push %d to the Queue = %d\n", val, Push(sq, val));
            }break;
            case 3:{
                printf("pop %d from the Queue = ", GetHead(sq));
                printf("%d\n", Pop(sq));
            }break;
        }
        print(sq);
    }
    #undef MAX_OP
    DestroyQueue(sq);
    return 0;
}

在这里插入图片描述

3.循环顺序队列扩容：

当循环顺序队列真的达到最大容量时（真溢出），可以对其进行扩容操作：

注意：注意：如果使用realloc进行扩容，则队列中的元素很可能会出现顺序错乱，故应该使用malloc或者calloc实现扩容操作

关键代码：

//SqQueue扩容操作
int expand(SqQueue *sq){
    int extend_size = sq->length;//扩容一倍
    int *p;
    //(1)开辟新的空间
    while(extend_size){
        p = (int *)malloc(sizeof(int) * (sq->length + extend_size));
        if(p != NULL) break;//malloc扩容成功
        extend_size >>= 1;//malloc扩容失败则将扩容容量extend缩小,再次尝试扩容
    }
    if(p == NULL) return 0;//循环扩容失败
    //(2)将原队列数据转移到新队列中
    for(int i = 0; i < sq->count; ++i){
        p[i] = sq->data[(i + sq->front) % sq->length];//逐个将队列中的元素进行转移
    }
    //手动释放原队列空间
    free(sq->data);
    sq->data = p;
    //更改新队列基本信息
    sq->front = 0, sq->rear = sq->count;
    sq->length += extend_size;
    return 1;
}

//5.队列入队
int Push(SqQueue *sq, int val){
    if(sq == NULL) return 0;
    if(sq->count == sq->length){
        //循环顺序队列已满需要扩容
        if(!expand(sq)){
            printf(RED("fail to expand !\n"));
            return 0;
        }
        printf(GREEN("success to expand! the new length = %d\n"), sq->length);
    }
    sq->data[sq->rear++] = val;
    if(sq->rear == sq->length) sq->rear = 0;//尾指针置0
    sq->count++;
    return 1;
}

完整程序：

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

#define COLOR(a, b) "\033[" #b "m" a "\033[0m"
#define RED(a) COLOR(a, 34)
#define GREEN(a) COLOR(a, 32)

typedef struct{
    int *data;
    int front, rear;
    int length;//容量
    int count;//元素个数
}SqQueue;

//1.队列初始化
SqQueue *InitQueue(int n){
    SqQueue *sq = (SqQueue *)malloc(sizeof(SqQueue));
    sq->data = (int *)malloc(sizeof(int) * n);
    sq->length = n;
    sq->front = sq->rear = 0;
    sq->count = 0;
    return sq;
}

//2.队列销毁
void DestroyQueue(SqQueue *sq){
    if (sq == NULL) return;
    free(sq->data);
    free(sq);
    return;
}

//3.队列判空
int QueueEmpty(SqQueue *sq){
    return sq->count == 0;
}

//4.获取队列队首元素
int GetHead(SqQueue *sq){
    if(sq->front != sq->rear) return sq->data[sq->front];
}

//SqQueue扩容操作
int expand(SqQueue *sq){
    int extend_size = sq->length;//扩容一倍
    int *p;
    //(1)开辟新的空间
    while(extend_size){
        p = (int *)malloc(sizeof(int) * (sq->length + extend_size));
        if(p != NULL) break;//malloc扩容成功
        extend_size >>= 1;//malloc扩容失败则将扩容容量extend缩小,再次尝试扩容
    }
    if(p == NULL) return 0;//循环扩容失败
    //(2)将原队列数据转移到新队列中
    for(int i = 0; i < sq->count; ++i){
        p[i] = sq->data[(i + sq->front) % sq->length];//逐个将队列中的元素进行转移
    }
    //手动释放原队列空间
    free(sq->data);
    sq->data = p;
    //更改新队列基本信息
    sq->front = 0, sq->rear = sq->count;
    sq->length += extend_size;
    return 1;
}

//5.队列入队
int Push(SqQueue *sq, int val){
    if(sq == NULL) return 0;
    if(sq->count == sq->length){
        //循环顺序队列已满需要扩容
        if(!expand(sq)){
            printf(RED("fail to expand !\n"));
            return 0;
        }
        printf(GREEN("success to expand! the new length = %d\n"), sq->length);
    }
    sq->data[sq->rear++] = val;
    if(sq->rear == sq->length) sq->rear = 0;//尾指针置0
    sq->count++;
    return 1;
}

//6.队列出队
int Pop(SqQueue *sq){
    if(sq == NULL) return 0;
    if(QueueEmpty(sq)) return 0;
    sq->front++;
    if(sq->front == sq->length) sq->front = 0;//头指针置0
    sq->count--;
    return 1;
}

void print(SqQueue *sq){
    printf("Queue(%d) : [", sq->count);
    for(int i = 0; i < sq->count; ++i){
        i && printf(", ");
        printf("%d", sq->data[(i + sq->front) % sq->length]);
    }
    printf("]\n");
    return ;
}

int main(){
    srand(time(0));
    #define MAX_OP 20
    SqQueue *sq = InitQueue(1);
    for(int i = 0; i < MAX_OP; ++i){
        int op = rand() % 4;
        int val = rand() % 100;
        switch(op){
            case 0:
            case 1:
            case 2:{
                printf("push %d to the Queue = %d\n", val, Push(sq, val));
            }break;
            case 3:{
                printf("pop %d from the Queue = ", GetHead(sq));
                printf("%d\n", Pop(sq));
            }break;
        }
        print(sq);
    }
    #undef MAX_OP
    DestroyQueue(sq);
    return 0;
}

在这里插入图片描述

4.链队列操作：

对比于顺序队列，链队列不会出现假溢出（循环顺序队列解决）和真溢出（循环顺序队列扩容解决）的情况，实现较为简单：

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

typedef struct Node {
    int data;
    struct Node *next;
} Node;

typedef struct LinkQueue {
    Node *front, *rear;
    int length;
} LinkQueue;

Node *InitNode(int val) {
    Node *p = (Node *)malloc(sizeof(Node));
    p->data = val;
    p->next = NULL;
    return p;
}

LinkQueue *InitLinkQueue() {
    LinkQueue *lq = (LinkQueue *)malloc(sizeof(LinkQueue));
    lq->front->next = NULL;
    lq->rear = lq->front;
    lq->length = 0;
    return lq;
}

void DestroyNode(Node *node) {
    if (node == NULL) return;
    free(node);
    return;
}

void DestroyQueue(LinkQueue *lq) {
    if (lq == NULL) return;
    Node *p = lq->front->next, *temp;
    while (p != NULL) {
        temp = p->next;
        DestroyNode(p);
        p = temp;
    }
    free(lq);
    return;
}

int Empty(LinkQueue *lq) {
    return lq->length == 0;
}

int Push(LinkQueue *lq, int val) {
    if (lq == NULL) return 0;
    Node *temp = InitNode(val);
    lq->rear->next = temp;
    lq->rear = temp;
    lq->length += 1;
    return 1;
}

int Pop(LinkQueue *lq) {
    if (lq == NULL) return 0;
    if (Empty(lq)) return 0;
    Node *temp = lq->front->next;
    lq->front->next = lq->front->next->next;
    DestroyNode(temp);
    lq->length -= 1;
    if (lq->length == 0) lq->rear = lq->front;
    return 1;
}

int GetHead(LinkQueue *lq) {
    return lq->front->next->data;
}

void print(LinkQueue *lq) {
    if (lq == NULL) return;
    printf("Queue(%d) : [", lq->length);
    for (Node *p = lq->front->next; p != NULL; p = p->next) {
        p != lq->front->next && printf(", ");
        printf("%d", p->data);
    }
    printf("]\n");
    return;
}

int main(){
    srand(time(0));
    LinkQueue *lq = InitLinkQueue();
    #define MAX_OP 20
    for (int i = 0; i < MAX_OP; ++i) {
        int op = rand() % 4;
        int val = rand() % 100;
        switch (op) {
            case 0:
            case 1:
            case 2: {
                printf("push %d to the Queue = %d\n", val, Push(lq, val));
            } break;
            case 3: {
                if (!Empty(lq)) {
                    printf("pop %d from the Queue = ", GetHead(lq));
                    printf("%d\n", Pop(lq));
                }
            } break;
        }
        print(lq);
    }
    #undef MAX_OP
    DestroyQueue(lq);
    return 0;
}

在这里插入图片描述

报错原因分析：初始化链队列时出现segment fault访问越界错误

在调用InitLinkQueue()方法时，lq->front->next = NULL;访问越界第一个node结点并不存在，无法访问其next域。

设置虚拟头结点处理：

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

typedef struct Node {
    int data;
    struct Node *next;
} Node;

typedef struct LinkQueue {
    Node front, *rear;//虚拟头结点
    int length;
} LinkQueue;

Node *InitNode(int val) {
    Node *p = (Node *)malloc(sizeof(Node));
    p->data = val;
    p->next = NULL;
    return p;
}

LinkQueue *InitLinkQueue() {
    LinkQueue *lq = (LinkQueue *)malloc(sizeof(LinkQueue));
    lq->front.next = NULL;
    lq->rear = &(lq->front);
    lq->length = 0;
    return lq;
}

void DestroyNode(Node *node) {
    if (node == NULL) return;
    free(node);
    return;
}

void DestroyQueue(LinkQueue *lq) {
    if (lq == NULL) return;
    Node *p = lq->front.next, *temp;
    while (p != NULL) {
        temp = p->next;
        DestroyNode(p);
        p = temp;
    }
    free(lq);
    return;
}

int Empty(LinkQueue *lq) {
    //return lq->rear == NULL;
    return lq->length == 0;
}

int Push(LinkQueue *lq, int val) {
    if (lq == NULL) return 0;
    Node *temp = InitNode(val);
    lq->rear->next = temp;
    lq->rear = temp;
    lq->length += 1;
    return 1;
}

int Pop(LinkQueue *lq) {
    if (lq == NULL) return 0;
    if (Empty(lq)) return 0;
    Node *temp = lq->front.next;
    lq->front.next = lq->front.next->next;
    DestroyNode(temp);
    lq->length -= 1;
    if (lq->length == 0) lq->rear = &(lq->front);
    return 1;
}

int GetHead(LinkQueue *lq) {
    return lq->front.next->data;
}

void print(LinkQueue *lq) {
    if (lq == NULL) return;
    printf("Queue(%d) : [", lq->length);
    for (Node *p = lq->front.next; p != NULL; p = p->next) {
        p != lq->front.next && printf(", ");
        printf("%d", p->data);
    }
    printf("]\n");
    return;
}

int main(){
    srand(time(0));
    LinkQueue *lq = InitLinkQueue();
    #define MAX_OP 20
    for (int i = 0; i < MAX_OP; ++i) {
        int op = rand() % 4;
        int val = rand() % 100;
        switch (op) {
            case 0:
            case 1:
            case 2: {
                printf("push %d to the Queue = %d\n", val, Push(lq, val));
            } break;
            case 3: {
                if (!Empty(lq)) {
                    printf("pop %d from the Queue = ", GetHead(lq));
                    printf("%d\n", Pop(lq));
                }
            } break;
        }
        print(lq);
    }
    #undef MAX_OP
    DestroyQueue(lq);
    return 0;
}

在这里插入图片描述
报错成功解决

报错最后修改于2022.5.3

hello world 999
关注
  • 2
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
可扩充循环队列
09-26
可扩充循环队列可扩充循环队列可扩充循环队列可扩充循环队列可扩充循环队列
数据结构——循环队列（C++实现）
最新发布
qq_67693066的博客
04-22 766
数据结构——循环队列（C++）
04.数据结构之循环队列（扩容版本）
xiaoduan6的博客
04-06 211
队列的定义 typedef struct Queue { int* data; int lengeth; int head, tail, length; int count; }Queue; 取出队头元素操作 int front(Queue* q) { return q->data[q->head]; } 队列的初始化操作 Queue* init(int n) { Queue* q = (Queue*)malloc(sizeof(Queue)
【数据结构】11.循环队列的实现
weixin_46955173的博客
01-14 883
目录 一、循环列表相对于普通列表的不同 二、图解分析 1.初始状态 2.添加元素后 3.队列满时 4.队列空时 5.扩缩容的问题 三、代码及详细注解 一、循环列表相对于普通列表的不同 1.普通列表只是用线性表实现类实现的，只有一个索引下标 2.入队好说，直接在尾部添加即可 3.而出队的话，需要把第一个元素移出去，后面的依次往前移动。而循环列表就是要解决这个问题产生的哦 4.循环队列设置了两个索引下标front,rear 5.front头指针，rear尾指针，刚开始...
循环队列及扩容
Huo_Chuanfei的博客
12-05 472
#include <stdio.h> #include <stdlib.h> #include <string.h> #include <time.h> typedef struct Queue { int *data; int head; int tail; int length; int cnt; } Queue; Queue *init(int n) { Queue *q = (Queue *)malloc(sizeof(Queue));
循环队列如何根据实际需要动态地扩展空间？
weixin_42575505的博客
01-07 206
循环队列可以使用动态数组的实现方式来动态地扩展空间。 当队列满时，我们可以创建一个新的更大的数组，然后把旧数组中的数据拷贝到新数组中，再将旧数组指针指向新数组，这样就可以继续向队列中添加元素了。 但是，当我们扩展数组的大小时，需要注意保证队列的循环性，也就是说，需要把队列的队尾元素正确地放在新数组的最后一个位置。 例如，假设当前队列的容量为 4，已有元素 A, B, C, D，其中队尾元素为 D，...
队列的学习(二) 循环队列
weixin_43740011的博客
05-31 804
循环队列是一种高效的队列实现方式，可以避免普通队列在删除元素时进行数据搬移操作。循环队列的应用场景非常广泛，例如手机短信发送、多线程任务调度和缓存淘汰算法等。
数据结构c语言版第二版(严蔚敏)第三章笔记
couchpotatoshy的博客
09-26 1319
顺序栈、链式栈、顺序队列、链式队列的实现以及栈与递归的关系
线性结构---栈和队列
小S的博客
10-13 1023
线性结构---栈和队列
【数据结构】栈(stack)、队列(queue)【顺序栈+可扩容顺序栈+链式栈】【循环可扩容队列+链式队列】（C语言代码）
crr411422的博客
03-23 804
基础扫盲：栈(stack)、队列(queue)的图文理解。（可根据自身情况略过该部分） 栈实现：顺序栈+可扩容循序栈+链式栈（完整代码） 队列实现：循环可扩容队列+链式队列（完整代码）
自扩充的Lock-Free并发环形队列算法
02-15
环形链表具有避免申请释放节点元素的优点，但为了减少资源使用所以不能分配无穷大的节点数,只能根据具体需求分配一定数量的节点数，正因为如此，可能由于对系统分析不足而导致初始化的节点数不一定能满足队列的容量需求，这个时候就需要队列具有自适应的扩充队列节点数的功能，基于锁（Lock-Base）的算法实现扩充是相当容易的，但基于锁无关（Lock-Free）实现起来难度较大，下面将使用伪代码介绍基于Lock-Free实现可自适应扩充的环形并发队列算法，并提出了优化方案以使特定环境下能再提高队列效率。
2、上机实验报告二栈与队列.docx
03-16
数据结构栈与队列实验报告
32位微机原理上机实验报告：显示输出实验
07-08
32位微机原理上机实验报告：显示输出实验，程序实验步骤等
32位微机原理上机实验报告：数据传送实验
07-08
32位微机原理上机实验报告：数据传送实验，程序实验步骤等
实验一：数据定义与简单查询.docx
05-17
此文档包含上机操作及相关语句。 1. 学习目的：熟练掌握和使用MySQL创建数据库、表索引和修改表结构，并学会使用Workbench 查询分进行结果分析。 2. 学会掌握查看、修改数据库和表的属性的方法 3、在建立好的数据库...
32位微机原理上机实验报告：显示程序实验
07-08
32位微机原理上机实验报告：显示程序实验，程序实验步骤等
数据结构课后题目源码
baidu_24736703的博客
05-23 2014
题目描述：     循环队列采用一维数组作为它的存储表示，往往很难确定到底数组需要设置多少元素才够用，设置太多元素，可能造成浪费，设置太少元素，可能造成溢出，为此可以改写队列的插入和删除算法，自动根据需要调整队列的存储数组的大小。     （1）改写队列的插入函数，当对列满并需要插入新元素时将数组空间扩大一倍，使新元素得以插入。     （2）改写队列的删除函数，当队列元素少于数组空间的1/
数组实现可扩容循环队列
qq_33723924的博客
10-05 1404
/** * @author zfl * 数组实现可扩容循环队列 */ public class Queue { private Object[] queArray; private int maxSize; private int front; private int rear; private int nItems; public Queue(int initialCapa...
什么是队列（基础概念/顺序队列/链式队列/动态扩容/循环队列）含示例代码
留夕的博客
04-20 598
定义 如何理解“队列” 队列是一个操作受限的线性表 具有先进先出的性质 跟「栈」一样，分为顺序队列和链式队列 用数组实现的顺序队列和用链表实现的链式队列 主要要关注队满和队空条件 线性队列 > 队满：tail == n | 队空（没有数据）：head == tail 链式队列 > 队满：无界 | 队空：head.next = tail 线性队列的数据搬迁：当队满时，...
上机实验三：Newton法程序设计
05-26
好的，下面是Newton法程序的设计： 首先，我们需要确定使用的函数和初始值。假设我们要求解的方程是 f(x) = x^3 - 5x + 3，那么我们可以选择 x0 = 1 作为初始值。 接下来，我们需要编写一个函数来计算 f(x) 和 f'(x)。在这个例子中，f(x) 和 f'(x) 的表达式分别为： f(x) = x^3 - 5x + 3 f'(x) = 3x^2 - 5 接着，我们可以编写一个函数来实现 Newton 法的迭代公式： x1 = x0 - f(x0) / f'(x0) 然后，我们需要设置一个停止条件。在这个例子中，我们可以选择当两次迭代之间的误差小于某个阈值时停止迭代。具体来说，我们可以计算每次迭代的 x 值之间的差值，当它小于某个给定的阈值时，我们认为已经达到了精度要求。 最后，我们可以将所有的代码组合起来，得到完整的 Newton 法程序。下面是一个示例程序： ``` #include <iostream> #include <cmath> using namespace std; double f(double x) { return pow(x, 3) - 5 * x + 3; } double df(double x) { return 3 * pow(x, 2) - 5; } int main() { double x0 = 1; // 初始值 double x1 = x0 - f(x0) / df(x0); // 迭代公式 double eps = 1e-6; // 精度要求 int n = 0; // 迭代次数 while (abs(x1 - x0) > eps) { x0 = x1; x1 = x0 - f(x0) / df(x0); n++; } cout << "x = " << x1 << endl; cout << "迭代次数: " << n << endl; return 0; } ``` 以上就是Newton法程序设计的基本思路和实现方法。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值