队列（笔记）

已于 2023-04-13 10:42:53 修改
阅读量73 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 算法 c语言
于 2023-03-29 20:42:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ztt19990421/article/details/129784158
版权

一、队列的概念及结构

队列:只允许在一端进行插入数据操作， 在另一端进行删除 数据操作的特殊线性表,队列具有先进先出FIFO(First In First Out)
入队列:进行插入操作的一端称为队尾；
出队列:进行删除操作的一端称为队头。

//test.c
#include "Stack.h"
#include "Queue.h"
void TestStack1()
{
	ST st;
	StackInit(&st);

	StackPush(&st, 1);
	StackPush(&st, 2);
	StackPush(&st, 3);
	StackPush(&st, 4);

	StackPop(&st);
	StackPop(&st);
	StackPop(&st);
	StackPop(&st);
	//StackPop(&st);
	//printf("%d", StackTop(&st));

	StackDestroy(&st);
}
void TestStack2()
{
	ST st;
	StackInit(&st);

	StackPush(&st, 1);
	StackPush(&st, 2);
	StackPush(&st, 3);
	StackPush(&st, 4);

	printf("%d ", StackTop(&st));
	StackPop(&st);
	printf("%d ", StackTop(&st));
	StackPop(&st);

	StackPush(&st, 5);
	StackPush(&st, 6);

	while (!StackEmpty(&st))//输出数据
	{
		printf("%d ", StackTop(&st));
		StackPop(&st);
	}

	StackDestroy(&st);
}
void TestQueue1()
{
	Queue q;
	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePush(&q, 3);
	QueuePush(&q, 4);

	QueuePop(&q);
	QueuePop(&q);
	QueuePop(&q);
	QueuePop(&q);
	//QueuePop(&q);

	//printf("%d\n", QueueFront(&q));
	//printf("%d\n", QueueBack(&q));

	QueuePush(&q, 10);
	QueuePush(&q, 20);

	QueueDestroy(&q);
}
void TestQueue2()
{
	Queue q;
	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QDataType front = QueueFront(&q);
	printf("%d ", front);
	QueuePop(&q);

	QueuePush(&q, 3);
	QueuePush(&q, 4);

	while (!QueueEmpty(&q))
	{
		QDataType front = QueueFront(&q);
		printf("%d ", front);
		QueuePop(&q);
	}
	printf("\n");
}
int main()
{
	//TestStack2();
	TestQueue2();
	return 0;
}
//Queue.h
#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>
typedef int QDataType;
typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType data;
}QueueNode;
typedef struct Queue
{
	QueueNode* head;
	QueueNode* tail;
	// size_t _size;
}Queue;
//void QueueInit(QueueNode** pphead, QueueNode** pptail);
void QueueInit(Queue* pq);
void QueueDestroy(Queue* pq);
void QueuePush(Queue* pq, QDataType x);
void QueuePop(Queue* pq);
QDataType QueueFront(Queue* pq);
QDataType QueueBack(Queue* pq);
int QueueSize(Queue* pq);
bool QueueEmpty(Queue* pq);
#include<assert.h>
#include<stdbool.h>
typedef int QDataType;
typedef struct QueueNode
{
    struct QueueNode* next;
    QDataType data;
}QueueNode;
typedef struct Queue
{
    QueueNode* head;
    QueueNode* tail;
}Queue;
void QueueInit(Queue* pq)
{
    assert(pq);
    pq->head=NULL;
    pq->tail=NULL;
}
void QueueDestory(Queue* pq)
{
    assert(pq);
    QueueNode* cur=pq->head;
    while(cur!=NULL)
    {
        QueueNode* next=cur->next;//定义当前结点的下一个结点
        free(cur);//删掉结点
        cur=next;//往下走
    }
    pq->head=pq->tail=NULL;//置空
}
//进栈，队尾进
void QueuePush(Queue* pq,QDataType x)
{
    assert(pq);
    QueueNode* newnode=(QueueNode*)malloc(sizeof(QueueNode));
    newnode->data=x;
    newnode->next=NULL;// newnode初始化
    //队列为空
    if(pq->head=NULL)
    {
        pq->head=pq->tail= newnode;//newnode为队头也为队尾
    }
    else 
    {
        pq->tail->next= newnode;//队尾指向newnode
        pq->tail= newnode;//newnode变为新的tail
    }
}
//出栈，队头出
void QueuePop(Queue* pq)
{
    assert(pq);
    assert(!QueueEmpty(pq));//保证pop的时候一定有数据
    QueueNode* next=pq->head->next;
    free(pq->head);
    pq->head=next;
    if(pq->head==NULL)//为空，处理完了，链表删完了
    {
       pq->tail=NULL;
    }
}
QDataType QueueFront(Queue* pq)//取队头数据
{
    assert(pq);
    assert(!QueueEmpty(pq));
    return pq->head->data;
}
QDataType QueueBack(Queue* pq)//取队尾数据
{ 
    assert(pq);
    assert(!QueueEmpty(pq));
    return pq->tail->data;
}
int QueueSize(Queue* pq);
{
    assert(pq);
    int n=0;
    QueueNode* cur=pq->head;
    while(cur)
    {
        ++n;//大小加1
        cur=cur->next;//往下走
    }
    return n;
}
bool QueueEmpty(Queue* pq)//判断队列是不是为空
{
    assert(pq);//判断结构体不为空
    return pq->head==NULL;
}

出栈操作
出栈操作

二、循环队列（数组/链表）

1、符合先进先出；2、空间大小固定。

入数据（tail向后移）
出数据（front向后移）
之前用过的空间可以重复利用
环形队列

重点:循环队列无论使用数组实现还是链表实现，都要多开一个空间，也就意味着要是一个存k个数据的循环队列，要开k+ 1个空间，否则无法实现判空和判满。若不多开一个空间的话 front == tail    无法判断队列是空还是满。 

front==tail   空            (tail+1)%(k+1)==front   满 (tail->next==front)

三、例题

1.用队列实现栈（力扣）

不能改变队列结构，只能调用队列提供的接口函数实现。①入数据，往不为空的队列入，保持另一个队列为空；②出数据的时候，依次出队头的数据，转移另一个队列保存。只剩最后一个值，pop掉。

typedef int QDataType;
typedef struct QueueNode
{
    struct QueueNode* next;
    QDataType data;
}QueueNode;
typedef struct Queue
{
    QueueNode* head;
    QueueNode* tail;
}Queue;
typedef struct {
    Queue q1;
    Queue q2;
} MyStack;//没有typedef就是变量，有typedef就是结构体
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = pq->tail = NULL;
}
void QueueDestory(Queue* pq)
{
	assert(pq);
	QueueNode* cur = pq->head;
	while (cur)
	{
		QueueNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->head = pq->tail = NULL;
}
// 队尾入
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	if (pq->tail == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
}
// 队头出
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(pq->head);
	// 1、一个
	// 2、多个
	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QueueNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}
}
QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(pq->head);
	return pq->head->data;
}
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(pq->head);
	return pq->tail->data;
}
int QueueSize(Queue* pq)
{
	assert(pq);
	int size = 0;
	QueueNode* cur = pq->head;
	while (cur)
	{
		++size;
		cur = cur->next;
	}
	return size;
}
bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->head == NULL;
}
void QueueInit(Queue* pq);
void QueueDestory(Queue* pq);
void QueuePush(Queue* pq,QDataType x);
void QueuePop(Queue* pq);
QDataType QueueFront(Queue* pq);
QDataType QueueBack(Queue* pq);
int QueueSize(Queue* pq);
bool QueueEmpty(Queue* pq);

MyStack* myStackCreate() {
    MyStack* st=(MyStack*)malloc(sizeof(MyStack));
    QueueInit(&st->q1);
    QueueInit(&st->q2);
    return st;
}
void myStackPush(MyStack* obj, int x) {
    if(!QueueEmpty(&obj->q1))//q1不为空就往q1里push
    {
        QueuePush(&obj->q1,x);
    }
    else
    {
        QueuePush(&obj->q2,x);//否则往q2里push
    }
}
int myStackPop(MyStack* obj) {
    //默认q1为空q2不为空
    Queue* emptyQ=&obj->q1;
    Queue* nonemptyQ=&obj->q2;
    if(!QueueEmpty(&obj->q1))
    {
        emptyQ=&obj->q2;
        nonemptyQ=&obj->q1;//默认错误q1不为空q2为空
    }
    while(QueueSize(nonemptyQ)>1)
    {
        QueuePush(emptyQ,QueueFront(nonemptyQ));//取非空队列队头的数据导进去
        QueuePop(nonemptyQ);//把非空队列中的数据移入空队列中
    }
    int top=QueueFront(nonemptyQ);//返回栈顶数据
    QueuePop(nonemptyQ);
    return top;
}
int myStackTop(MyStack* obj) {
    //谁的数据不为空就为栈顶数据
    if(!QueueEmpty(&obj->q1))
    {
        return QueueBack(&obj->q1);
    }
    else
    {
        return QueueBack(&obj->q2);
    }
}
bool myStackEmpty(MyStack* obj) {//判断栈是否为空，要想栈为空必须两个队列都为空
    return QueueEmpty(&obj->q1)&&QueueEmpty(&obj->q2);
}
void myStackFree(MyStack* obj) {
    QueueDestory(&obj->q1);
    QueueDestory(&obj->q2);
    free(obj);
}
/**
 * Your MyStack struct will be instantiated and called as such:
 * MyStack* obj = myStackCreate();
 * myStackPush(obj, x);
 * int param_2 = myStackPop(obj);
 * int param_3 = myStackTop(obj);
 * bool param_4 = myStackEmpty(obj);
 * myStackFree(obj);
*/

 2. 用栈实现队列（力扣）

向pushST入数据，从popST出数据。pop栈里没有数据，要从push栈里导过来，popST中的数据就符合先进先出了。pushST不为空就往popST里导。

typedef int STDataType;
typedef struct Stack
{
   STDataType* a;
   int top;
   int capacity;
}ST;
void StackInit(ST* ps);
void StackDestory(ST* ps);
void StackPush(ST* ps,STDataType x);
void StackPop(ST* ps);
STDataType StackTop(ST* ps);//取栈顶数据
int StackSize(ST* ps);
bool StackEmpty(ST* ps);//判断栈是不是为空
void StackInit(ST* ps)
{
    assert(ps);//结构体的指针不能为空
    ps->a=NULL;
    ps->top=0;//初始化时，top给的是0，意味着top指向栈顶数据的下一个
    //ps->top=-1  初始化时，top给的是-1，意味着top指向栈顶数据
    ps->capacity=0;
}
//销毁栈
void StackDestory(ST* ps)
{
    assert(ps);
    free(ps->a);
    ps->a=NULL;
    ps->top=ps->capacity=0;
}
//数据进栈
void StackPush(ST* ps,STDataType x)
{
    assert(ps);
    if(ps->top==ps->capacity)//栈满
    {
        int newCapacity=ps->capacity==0?4:ps->capacity*2;//增容，若capacity如初始化时为0，扩容四个空间，否则扩容到原来的2倍
        STDataType* tmp=realloc(ps->a,sizeof(STDataType)*newCapacity); //realloc有空间就扩容，没有就相当于malloc
        if(tmp==NULL)
        {
           printf("realloc fail\n");
           exit(-1);//增容失败
        }
        ps->a=tmp;//开辟空间成功
        ps->capacity=newCapacity;
    }
    ps->a[ps->top]=x;//先把数据放在top位置
    ps->top++;//指向下一个位置
}
//出栈
void StackPop(ST* ps)
{
    assert(ps);
    assert(ps->top>0);//表示还有数据，不为空
    ps->top--;
}
//取栈顶数据
STDataType StackTop(ST* ps)
{
    assert(ps);
    assert(!StackEmpty(ps));//表示还有数据，不为空
    return ps->a[ps->top-1];
}
//栈的大小
int StackSize(ST* ps)
{
    assert(ps);
    return ps->top;
}
//判断栈是不是为空
bool StackEmpty(ST* ps)
{
    assert(ps);
    return ps->top==0;//为空返回真
}
typedef struct {
    ST pushST;
    ST popST;
} MyQueue;
MyQueue* myQueueCreate() {
    MyQueue* q=(MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&q->pushST);
    StackInit(&q->popST);
    return q;
}
void myQueuePush(MyQueue* obj, int x) {
    StackPush(&obj->pushST,x);//不管有没有数据直接入，向pushST入数据，从popST出数据
}
int myQueuePop(MyQueue* obj) {
    if(StackEmpty(&obj->popST))//pop栈里没有数据，要从push栈里导过来,popST中的数据就符合先进先出了
    {
        while(!StackEmpty(&obj->pushST))//pushST不为空就往popST里导
        {
            StackPush(&obj->popST,StackTop(&obj->pushST));//栈顶数据依次导过来，返回的是栈顶元素
            StackPop(&obj->pushST);//pushST删掉导出的数据
        }
    }
    int front=StackTop(&obj->popST);//pop不为空，变量先保存起来再删掉
    StackPop(&obj->popST);//删掉元素
    return front;
}
int myQueuePeek(MyQueue* obj) {
    if(StackEmpty(&obj->popST))//pop栈里没有数据，要从push栈里导过来,popST中的数据就符合先进先出了
    {
        while(!StackEmpty(&obj->pushST))//pushST不为空就往popST里导
        {
            StackPush(&obj->popST,StackTop(&obj->pushST));//栈顶数据依次导过来，返回的是栈顶元素
            StackPop(&obj->pushST);//pushST删掉导出的数据
        }
    }
    return StackTop(&obj->popST);//只取队头数据，不用删除
}
bool myQueueEmpty(MyQueue* obj) {
    return StackEmpty(&obj->pushST)&&StackEmpty(&obj->popST);//两个都为空才为空
}
void myQueueFree(MyQueue* obj) {
    StackDestory(&obj->pushST);
    StackDestory(&obj->popST);
    free(obj);
}
/**
 * Your MyQueue struct will be instantiated and called as such:
 * MyQueue* obj = myQueueCreate();
 * myQueuePush(obj, x);
 
 * int param_2 = myQueuePop(obj);
 
 * int param_3 = myQueuePeek(obj);
 
 * bool param_4 = myQueueEmpty(obj);
 
 * myQueueFree(obj);
*/

3.设计循环队列（力扣）

typedef struct {
    int*a;
    int front;
    int tail;
    int k;//环形队列存放数据的大小
} MyCircularQueue;
bool myCircularQueueIsEmpty(MyCircularQueue* obj);
bool myCircularQueueIsFull(MyCircularQueue* obj);//声明
MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* cq=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    cq->a=(int*)malloc(sizeof(int)*(k+1));
    cq->front=cq->tail=0;
    cq->k=k;//结构体初始化
    return cq;
}
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if (myCircularQueueIsFull(obj))
    return false;
    obj->a[obj->tail]=value;//把数据存放在tail处
    ++obj->tail;//tail往后
    obj->tail%=(obj->k+1);//判断数据是不是走到第k+1个，如果是的话，下一次tail变为第一个
    return true;
}
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    return false;
    ++obj->front;//tail往后
    obj->front%=(obj->k+1);//判断数据是不是走到第k+1个，如果是的话，下一次tail变为第一个
    return true;
}
int myCircularQueueFront(MyCircularQueue* obj) {//取队头数据
    if(myCircularQueueIsEmpty(obj))
    return -1;
    return obj->a[obj->front];
}
int myCircularQueueRear(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    return -1;
    if(obj->tail==0)//tail在第一个位置
    {
       return obj->a[obj->k];//最后一个值即为队尾的值
    }
    else
    {
       return obj->a[obj->tail-1];//普通情况下是tail的前一个
    }
}
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->front==obj->tail;
}
bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return (obj->tail+1)%(obj->k+1)==obj->front;
}
void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    free(obj);
}
/**
 * Your MyCircularQueue struct will be instantiated and called as such:
 * MyCircularQueue* obj = myCircularQueueCreate(k);
 * bool param_1 = myCircularQueueEnQueue(obj, value);
 
 * bool param_2 = myCircularQueueDeQueue(obj);
 
 * int param_3 = myCircularQueueFront(obj);
 
 * int param_4 = myCircularQueueRear(obj);
 
 * bool param_5 = myCircularQueueIsEmpty(obj);
 
 * bool param_6 = myCircularQueueIsFull(obj);
 
 * myCircularQueueFree(obj);
*/

我不要麦克风
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
栈和队列笔记包括栈和队列的定义、顺序栈出入栈、链栈的出入栈操作、顺序队列基本操作、链式队列基本操作等
04-03
栈和队列
队列（学习笔记）
qq_43986343的博客
08-16 491
队列的学习笔记
【数据结构】队列 笔记整理
weixin_51630192的博客
07-26 317
【数据结构】 队列部分笔记整理，包含循环队列、链式队列等知识。参考自《大话数据结构》，为本人整理的一些笔记，学习内容。
队列_笔记
My classmates
08-23 124
与栈类似但规则不一样，栈是先进后出只有一个口，队列是两个口规则先进先出一个口只能进，一个口只能出 .h #define MAX_SIZE 1024 //顺序队列结构体 typedef struct SEQQUEUE { void *data[MAX_SIZE]; int size; }SeqQueue; class Queue { public: Queu...
队列学习笔记
热门推荐
多思易掉发
09-01 3万+
一、队列 队列是只允许在一端进行插入操作，在另一端进行删除操作的线性表 先进先出、后进后出、操作受限的线性表 允许插入的一端被称为队尾（rear） 允许删除的一端被称为队头（front） 二、循环队列 队列头尾相接的顺序结构 ，把整个数组理解成一个圈圈 -------&gt;示例代码 !!!头文件 #pragma once #include &lt;iostream&gt; #inc...
我的消息队列md笔记
09-21
我的消息队列笔记.............................................................
计算机网络技术 队列笔记
02-06
Access-list 100 permit icmp any any R1（Config）# priority-list 1 protocol ip high tcp telnet 将telnet流量的优先级置为high R1（Config）# priority-list 1 protocol ip medium list 100 调用访问列表将...
kafka消息队列学习笔记
07-02
kafka消息队列学习笔记，kafka消息队列学习笔记，kafka消息队列学习笔记，kafka消息队列学习笔记，kafka消息队列学习笔记，kafka消息队列学习笔记，kafka消息队列学习笔记，kafka消息队列学习笔记，kafka消息队列...
消息队列activemq学习笔记
02-04
消息中间件的学习笔记
队列笔记
hqwhardwork的专栏
08-09 603
队列的用途： 先来先服务的原则： 订票系统，操作系统的作业调度，消息队列。 顺序队列 结构体中的数组用来存储入队的元素。 typedef struct { DATATYPE items[QUEUESIZE]; int front,rear; }SqQueue; 顺序队列的溢出问题。 1：队列满时还要进行入队操作，rear会超出数组的下标。上溢。 2：队列空时还要出队
队列
Hern（宋兆恒）
09-23 243
简介 队列是一个有序列表，可以用数组或是链表来实现。遵循先进先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出 数组模拟队列 队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明如下图, 其中 maxSize 是该队列的最大容量。 因为队列的输出、输入是分别从前后端来处理，因此需要两个变量 front及 rear分别记录队列前后端的下标，front 会随着数据输...
PHP消息队列实现及应用
weixin_30679823的博客
01-08 536
目前对消息队列并不了解其原理，本篇文章主要是通过慕课网学习归纳的一些笔记，为后续学习打下基础。 众所周知在对网站设计的时候，会遇到给用户“群发短信”，“订单系统有大量的日志”，“秒杀设计”等，服务器没法处理这种瞬间迸发的压力，这种情况要保证系统正常有效的使用，就需要“消息队列”的帮助。本篇主要通过消息队列的思路进行学习。 主要了解如下知识： 　　1、队列是个什么东西，他能干什么？ 　　2、...
数据结构---队列笔记
weixin_44501322的博客
10-29 206
关于数据结构队列的记录
C++ 链表、栈、队列
weixin_40535588的博客
12-05 4346
一、C++ 链表 链表实际上是线性表的链式存储结构，与数组不同的是，它是用一组任意的存储单元来存储线性表中的数据，存储单元不一定是连续的， 且链表的长度不是固定的，链表数据的这一特点使其可以非常的方便地实现节点的插入和删除操作 1.1 几种链表的介绍 1.1.1 单向链表 单向链表很容易理解，就说把指针当成一条链一样连接每一个节点，每个节点包含了一个或者多个数据。链表的存储单元不一定是连续的，长度不固定，主要用于方便实现节点的插入和删除操作。官方的话这里就不说了，作为数据结构里最基本的，感兴趣的童鞋自.
消息队列笔记
宏浩叔叔的博客
11-27 1021
常见消息队列：ActiveMQ、RabbitMQ、Kafka，阿里巴巴自主开发的Notify、MetaQ、RocketMQ等。 常用于解决：业务解耦/最终一致性/广播/错峰流控 如果下游有很多业务方关系你的系统发出的通知的时候 ，果断的使用消息队列吧 业界的一些为最终一致性而生的消息队列如notify（阿里）、QMQ(去哪儿)，设计初衷是为了交易系统中的高可靠通知。一种实现方案是通过补偿机制， 比如
栈、队列、优先队列笔记
西二旗的小飞飞
08-01 370
20. Valid Parentheses 150. Evaluate Reverse Polish Notation 71. Simplify Path 144. Binary Tree Preorder Traversal 94. Binary Tree Inorder Traversal 145. Binary Tree Postorder Traversal 341. Flatt
队列简单的笔记
做一个有信仰de人的博客
04-18 177
1.线性结构 1)线性结构作为最常用的数据结构，其特点是数据元素之间存在一对一的线性关系 2)线性结构有两种不同的存储结构，即顺序存储结构（数组）和链式存储结构（链表）。顺序存储的线性表称为顺序表，顺序表中的存储元素是连续的 3)链式存储的线性表称为链表，链表中的存储元素不一定是连续的，元素节点中存放数据元素以及相邻元素的地址信息 4)线性结构常见的有：数组、队列、链表和栈，后面我们会详细讲解...
freertos 消息队列 串口
最新发布
07-28
- *1* *2* *3* [【FreeRtos学习笔记】STM32 CubeMx——Message Queue（消息队列）](https://blog.csdn.net/DIVIDADA/article/details/128177243)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630",...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值