栈与队列的基本介绍和创建、销毁、出入、计算元素数量、查看元素等功能的c语言实现，以及栈的压入、弹出序列判断，栈结构的链式表示与实现

最新推荐文章于 2023-05-17 18:35:09 发布
最新推荐文章于 2023-05-17 18:35:09 发布
阅读量577 收藏 3
点赞数 1
分类专栏： C语言学习 数据结构 文章标签： 数据结构 c语言 c++ 开发语言 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Hidin/article/details/126166516
版权

一、栈和队列介绍

栈和队列是两种重要的线性结构，从数据结构来看，他们也是线性表，其特殊性在于它们的基本操作是线性表的子集，也就中功能受限的线性表，也被称为限定性的数据结构。

但从数据类型角度来看，它们是和线性表不大相同，有些时候它们被当作一种管理数据的规则。

二、栈结构

1、栈结构介绍

栈（stack) 是限定仅在表尾进行插入或删除操作和线性表（只有一端口能进出数据），对栈来说表尾和表头有特殊含义，表尾被称为栈顶，表头被称为栈底，没有元素的空表称为空栈，元素数量达到栈的容量称为满栈，数据添加到栈中叫入栈、压栈，数据从栈中删除叫出栈、弹栈，由于栈元素特殊添加和删除的规则，所以栈的元素会先进后出的现象，简称为LIFO（Last in first out）。

2、栈结构所具备的功能

1、创建栈

2、销毁栈

3、栈是否为空

4、栈是否为满

5、入栈

6、出栈

8、查看栈顶元素

9、栈元素数量

注：只有顺序栈结构才有需要判断栈是否满。

3、栈结构的顺序表示与实现

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#define TYPE int
​
typedef struct StackArray
{
    TYPE* base;
    int top;
    size_t cap;
}StackArray;
​
// 创建栈
StackArray* create_stack(size_t cap)
{
    // 之所以使用成员指针是为了兼顾笔试题
    StackArray* stack = malloc(sizeof(StackArray));
    stack->base = malloc(sizeof(TYPE)*cap);
    stack->cap = cap;
    // 初始值值决定的栈空、栈满、入栈、查看栈顶时的top的操作,
    stack->top = -1; 
    return stack;
}
​
// 销毁栈
void destroy_stack(StackArray* stack)
{
    free(stack->base);
    free(stack);
}
​
// 判断栈是否为空
bool empty_stack(StackArray* stack)
{
    // 因为top的初始值是-1
    return 0 > stack->top;
}
​
// 判断栈是否为满
bool full_stack(StackArray* stack)
{
    // 同上
    return stack->cap == stack->top+1;
}
​
// 入栈
bool push_stack(StackArray* stack,TYPE val)
{
    if(full_stack(stack))
        return false;
​
    // 同上
    stack->base[++stack->top] = val;
    return true;
}
​
// 出栈
bool pop_stack(StackArray* stack)
{
    if(empty_stack(stack))
        return false;
​
    stack->top--;
    return true;
}
​
// 计算栈元素数量
size_t size_stack(StackArray* stack)
{
    return stack->top+1;
}
​
// 查看栈顶
bool top_stack(StackArray* stack,TYPE* ptr)
{
    if(empty_stack(stack))
        return false;
    
    *ptr = stack->base[stack->top];
    return true;
}
​
int main(int argc,const char* argv[])
{
    int num;
    StackArray* stack = create_stack(10);
    for(int i=0; i<10; i++)
    {
        push_stack(stack,i);
        if(top_stack(stack,&num))
            printf("top %d\n",num);
    }
    printf("----------------------\n");
    while(!empty_stack(stack))
    {
        top_stack(stack,&num);
        printf("top %d\n",num);
        pop_stack(stack);
    }
}

常考的题：

栈的压入、弹出序列判断，入栈顺序：1 2 3 4 5 出栈顺序可否是：1 2 3 5 4

bool push_pop_order(int* arr1,int* arr2,size_t len)
{
    StackArray* stack = create_stack(len);
​
    int num;
    for(int i=0,j=0; i<len; i++)
    {
        push_stack(stack,arr1[i]);
        while(top_stack(stack,&num) && num == arr2[j] && pop_stack(stack))
            j++;
    }
​
    return empty_stack(stack);
}
​
bool IsPopOrder(int* pushV, int pushVLen, int* popV, int popVLen ) 
{
    if(pushVLen != popVLen)
        return false;
    
    int stack[popVLen] , top = -1;
    for(int i=0,j=0; i<pushVLen; i++)
    {
        stack[++top] = pushV[i];
        while(top>=0 && stack[top] == popV[j])
        {
            top--;
            j++;
        }
    }
    return 0 > top;
}
​
bool IsPopOrder(vector<int> pushV,vector<int> popV)
{
    stack<int> s;
    for(int i=0,j=0; i<pushV.size(); i++)
    {
        s.push(pushV[i]);
        while(!s.empty() && s.top()==popV[j])
        {
            s.pop();
            j++;
        }
    }
    return s.empty();
}

4、栈结构的链式表示与实现

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
​
#define TYPE int
​
typedef struct Node
{
    TYPE data;
    struct Node* next;
}Node;
​
Node* create_node(TYPE data)
{
    Node* node = malloc(sizeof(Node));
    node->data = data;
    node->next = NULL;
    return node;
}
​
typedef struct StackList
{
    Node* top;
    size_t cnt;
}StackList;
​
// 创建栈
StackList* create_stack(void)
{
    StackList* stack = malloc(sizeof(StackList));
    stack->top = NULL;
    stack->cnt = 0;
    return stack;
}
​
// 销毁栈
void destroy_stack(StackList* stack)
{
    while(NULL!=stack->top)
    {
        Node* node = stack->top;
        stack->top = node->next;
        free(node);
    }
​
    free(stack);
}
​
// 栈空
bool empty_stack(StackList* stack)
{
    return NULL == stack->top;
}
​
// 入栈
void push_stack(StackList* stack,TYPE data)
{
    Node* node = create_node(data);
    node->next = stack->top;
    stack->top = node;
    stack->cnt++;
}
​
// 出栈
bool pop_stack(StackList* stack)
{
    if(empty_stack(stack))
        return false;
    
    Node* node = stack->top;
    stack->top = node->next;
    free(node);
    stack->cnt--;
    return true;
}
​
// 查看栈顶
TYPE top_stack(StackList* stack)
{
    return stack->top->data;
}
​
// 元素数量
size_t size_stack(StackList* stack)
{
    return stack->cnt;
}
​
int main(int argc,const char* argv[])
{
    StackList* stack = create_stack();
    for(int i=0; i<10; i++)
    {
        push_stack(stack,i);
        if(!empty_stack(stack))
            printf("top %d\n",top_stack(stack));
    }
    printf("-------------------\n");
    while(!empty_stack(stack))
    {
        printf("top %d\n",top_stack(stack));
        pop_stack(stack);
    }
}

5、栈的应用

1、内存管理，比如栈内存，它所以叫栈内存就是因为它遵循着栈的后进先出的规则，它支持着函数调用，函数在传参数就是把参数先压入到栈内存，等跳转过去后再把参数从栈内存弹出。

2、特殊的算法，例如：进制转换、表达式解析、迷宫求解。

三、队列

1、队列介绍

它与栈刚好相反，是一种先进先出的线性表，它有两个端口添加、删除元素，一个端口只能添加元素，被称为入队，该端口被为队尾，另一个端口只能删除，被称为出队，该端口被称为队头。

2、队列结构所具备的功能

1、创建队列

2、销毁队列

3、队列是否为空

4、队列是否为满

5、入队

6、出队

8、查看队头元素

9、查看队尾元素

10、队列元素数量

注：只有顺序栈结构才有需要判断队列是否满。

3、队列结构的链式表示与实现

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
​
#define TYPE int
​
typedef struct Node
{
    TYPE data;
    struct Node* next;
}Node;
​
Node* create_node(TYPE data)
{
    Node* node = malloc(sizeof(Node));
    node->data = data;
    node->next = NULL;
    return node;
}
​
typedef struct QueueList
{
    Node* front;
    Node* rear;
}QueueList;
​
// 创建队列
QueueList* create_queue(void)
{
    QueueList* queue = malloc(sizeof(QueueList));
    queue->front = NULL;
    queue->rear = NULL;
    return queue;
}
​
// 销毁队列
void destroy_queue(QueueList* queue)
{
    while(NULL != queue->front)
    {
        Node* node = queue->front;
        queue->front = node->next;
        free(node);
    }
    free(queue);
}
​
// 判断队列是否为空
bool empty_queue(QueueList* queue)
{
    return NULL == queue->front;
}
​
// 入队
void push_queue(QueueList* queue,TYPE data)
{
    Node* node = create_node(data);
    if(empty_queue(queue))
    {
        queue->front = node;
        queue->rear = node;
        return;
    }
​
    queue->rear->next = node;
    queue->rear = node;
}
​
// 出队
bool pop_queue(QueueList* queue)
{
    if(empty_queue(queue))
        return false;
​
    Node* node = queue->front;
    queue->front = node->next;
    free(node);
}
​
// 查看队头元素，调用该函数前要先判断队列是否为空，否则就会使用到空指针
TYPE front_queue(QueueList* queue)
{
    return queue->front->data;
}
​
// 查看队尾元素，调用该函数前要先判断队列是否为空，否则就会使用到野指针
TYPE rear_queue(QueueList* queue)
{
    return queue->rear->data;
}
​
// 队列元素数量
size_t size_queue(QueueList* queue)
{
    size_t size = 0;
    for(Node* n=queue->front; NULL!=n; n=n->next)
    {
        size++;
    }
    return size;
}
​
int main(int argc,const char* argv[])
{
    QueueList* queue = create_queue();
    for(int i=0; i<10; i++)
    {
        push_queue(queue,i);
        printf("front:%d rear:%d\n",
            front_queue(queue),
            rear_queue(queue));
    }
    printf("---------------------\n");
    while(!empty_queue(queue))
    {
        printf("front:%d rear:%d\n",
            front_queue(queue),
            rear_queue(queue));
        pop_queue(queue);
    }
}

4、顺序队列的表示与实现

顺序栈的栈顶下标会随着元素入栈增大，元素出栈减小，从而让空间重复使用，而顺序队列的队头指针和队尾指针，会随着元素的入队出队一直增加，无法重复使用，而形成一次性的数据结构。

为了避免这种情况，当队头下标的队尾下标到达存储空间的末尾时，要想办法把队头下标的队尾下标"回头"，就是把顺序队列的存储空间当作一个"环形"，循环使用，所以顺序队列也叫循环队列。

带计数器版本的循环队列：

1、解决了计算元素数量的问题

2、解决了判断队列空、满状态的问题

3、缺点就是增加了一个成员，在创建、入队、出队时都要操作它。

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
​
#define TYPE int
​
typedef struct QueueArray
{
    TYPE* base;
    int front;
    int rear;
    size_t cnt;
    size_t cap;
}QueueArray;
​
// 创建队列
QueueArray* create_queue(size_t cap)
{
    QueueArray* queue = malloc(sizeof(QueueArray));
    queue->base = malloc(sizeof(TYPE)*cap);
    queue->cap = cap;
    queue->front = 0;
    queue->rear = -1;
    queue->cnt = 0;
    return queue;
}
​
// 销毁队列
void destroy_queue(QueueArray* queue)
{
    free(queue->base);
    free(queue);
}
​
// 判断队列是否为空
bool empty_queue(QueueArray* queue)
{
    return 0 == queue->cnt;
}
​
// 判断队列是否为满
bool full_queue(QueueArray* queue)
{
    return queue->cnt == queue->cap;
}
​
// 入队
bool push_queue(QueueArray* queue,TYPE data)
{
    if(full_queue(queue))
        return false;
​
    queue->rear = (queue->rear+1)%queue->cap;
    queue->base[queue->rear] = data;
    queue->cnt++;
    return true;
}
​
// 出队
bool pop_queue(QueueArray* queue)
{
    if(empty_queue(queue))
        return false;
​
    queue->front = (queue->front+1)%queue->cap;
    queue->cnt--;
    return true;
}
​
// 查看队头元素,判断队列是否为空
TYPE front_queue(QueueArray* queue)
{
    return queue->base[queue->front];
}
​
// 查看队尾元素
TYPE rear_queue(QueueArray* queue)
{
    return queue->base[queue->rear];
}
​
// 队列元素数量
size_t size_queue(QueueArray* queue)
{
    return queue->cnt;
}
​
int main(int argc,const char* argv[])
{
    QueueArray* queue = create_queue(10);
    for(int i=0; i<10; i++)
    {
        push_queue(queue,i);
        printf("front:%d rear:%d\n",
            front_queue(queue),
            rear_queue(queue));
    }
    printf("---------------------\n");
    while(!empty_queue(queue))
    {
        printf("front:%d rear:%d\n",
            front_queue(queue),
            rear_queue(queue));
        pop_queue(queue);
    }
    printf("---------------------\n");
    for(int i=0; i<10; i++)
    {
        push_queue(queue,i);
        printf("front:%d rear:%d\n",
            front_queue(queue),
            rear_queue(queue));
    }
    printf("---------------------\n");
    while(!empty_queue(queue))
    {
        printf("front:%d rear:%d\n",
            front_queue(queue),
            rear_queue(queue));
        pop_queue(queue);
    }
    destroy_queue(queue);
    return 0;
}

不带计数器版本的循环队列：

1、如何判断队列空、状态?

把队头下标初始化为front=0，队尾下标也初始化rear=0，队列空时的判断条件是front == rear，但随机队列的使用，队列满时的判断也是front == rear。

解决方法就是把队列的最后一个位置空置不使用，这样队列满的状态front == rear+1;

2、如何计算队列元素数量?

(rear-front+cap)%cap

3、查看队尾元素

base[(read-1+cap)%cap]

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
​
#define TYPE int
​
typedef struct QueueArray
{
    TYPE* base;
    int front;
    int rear;
    size_t cap;
}QueueArray;
​
// 创建队列
QueueArray* create_queue(size_t cap)
{
    QueueArray* queue = malloc(sizeof(QueueArray));
    queue->base = malloc(sizeof(TYPE)*cap+1);
    queue->cap = cap+1;
    queue->front = 0;
    queue->rear = 0;
    return queue;
}
​
// 销毁队列
void destroy_queue(QueueArray* queue)
{
    free(queue->base);
    free(queue);
}
​
// 判断队列是否为空
bool empty_queue(QueueArray* queue)
{
    return queue->front == queue->rear;
}
​
// 判断队列是否为满
bool full_queue(QueueArray* queue)
{
    return queue->front == (queue->rear+1)%queue->cap;
}
​
// 入队
bool push_queue(QueueArray* queue,TYPE data)
{
    if(full_queue(queue))
        return false;
​
    queue->base[queue->rear] = data;
    queue->rear = (queue->rear+1)%queue->cap;
    return true;
}
​
// 出队
bool pop_queue(QueueArray* queue)
{
    if(empty_queue(queue))
        return false;
​
    queue->front = (queue->front+1)%queue->cap;
    return true;
}
​
// 查看队头元素,判断队列是否为空
TYPE front_queue(QueueArray* queue)
{
    return queue->base[queue->front];
}
​
// 查看队尾元素
TYPE rear_queue(QueueArray* queue)
{
    return queue->base[(queue->rear - 1 + queue->cap) % queue->cap];
}
​
// 队列元素数量
size_t size_queue(QueueArray* queue)
{
    return (queue->rear - queue->front + queue->cap) % queue->cap;
}
​
int main(int argc,const char* argv[])
{
    QueueArray* queue = create_queue(10);
    for(int i=0; i<10; i++)
    {
        push_queue(queue,i);
        printf("front:%d rear:%d\n",
            front_queue(queue),
            rear_queue(queue));
    }
    printf("---------------------\n");
    while(!empty_queue(queue))
    {
        printf("front:%d rear:%d\n",
            front_queue(queue),
            rear_queue(queue));
        pop_queue(queue);
    }
    printf("---------------------\n");
    for(int i=0; i<10; i++)
    {
        push_queue(queue,i);
        printf("front:%d rear:%d\n",
            front_queue(queue),
            rear_queue(queue));
    }
    printf("---------------------\n");
    while(!empty_queue(queue))
    {
        printf("front:%d rear:%d\n",
            front_queue(queue),
            rear_queue(queue));
        pop_queue(queue);
    }
    destroy_queue(queue);
}

4、队列的应用

队列结构一般应用于业务处理，例如：银行叫号系统，12306购票系统，电商的订单处理等。

kennan_pro
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言中栈和队列实现表达式求值的实例
08-29
C语言中栈和队列实现表达式求值的实例 栈和队列是数据结构中两个非常重要的概念，它们在计算机科学和编程语言中有着广泛的应用。栈和队列可以用来实现表达式求值，下面我们将通过C语言来实现栈和队列实现表达式求值...
栈和队列笔记包括栈和队列的定义、顺序栈出入栈、链栈的出入栈操作、顺序队列基本操作、链式队列基本操作等
最新发布
04-03
栈和队列
栈和队列之行编辑程序
zzu-hust-madd
10-23 259
行编辑程序 算法描述 接受用户从终端输入的程序或数据，并存入用户的数据区。 由于用户在终端上进行输入时，不能保证不出差错，因此，若在编辑程序中，“每接受一个字符即存入用户数据区”的做法显然不是最恰当的。较好的做法是，设立一个输入缓冲区，用以接受用户输入的一行字符，然后逐行存入用户数据区。 允许用户输入出差错，并在发现有误时可以及时更正。 例如，当用户发现刚刚键入的一个字符是错的时，可补进一个退格符...
栈和队列（C语言版）
坚持是一种品质
02-18 6687
栈和队列是在程序中最常被用到的数据结构，其重要性不言而喻。栈： 定义：限定仅在表尾进行插入和删除操作的线性表，因此表尾称之为栈顶,表头为栈底，重要特点是后进先出（LIFO）操作： InitStack(&S) 初始化一个栈 DestoryStack(&S)销毁一个已经存在的栈 ClearStack(&S)清空一个栈 StackEmpty(S)判断已存在的栈是否为空 St
数据结构与算法-栈和队列
weixin_45366970的博客
04-18 160
一、栈 1.定义 栈是线性表的一种特殊形式，它的数据只能满足先入后出。 2.C语言实现 （1）顺序表实现栈 #include<stdio.h> #include<stdlib.h> //建立顺序表数据类型(动态) typedef struct List { int* data; //数据域 int length; //顺序表的实际长度 }Sqlist; //初始化栈 void Init(Sqlist **top) { (*top)=(Sqlist*)malloc(si
栈和队列思想
qq_31997185的博客
09-22 219
1. 利用栈思想判断给定的一串括号是否左右匹配。 思路：如果字符是左括号，则存入栈，如果是右括号，判断栈顶括号是否与它匹配，匹配的话弹出，如果不匹配或者遍历完括号串后栈不为空，说明该串括号不是左右匹配。 def bracket_match(str_s): if not str_s: return None dict_match = {'(':')','[':']','{':'}'} bracket = [] for ch in str_s:
六、数据结构设计-栈与队列
Ray Home
10-01 719
数据结构设计相关，包括LRU、LFU、栈和队列应用、单调栈、优先级队列等
huiw.dsp.rar_回文栈和队列_用栈和队列编写判断回文的c语言程序
09-24
具体实现时，需要定义栈或队列的结构体，包括数据元素和指向下一个元素的指针，同时提供入栈、出栈、入队、出队等操作。 这个压缩包中的“huiw.dsp.text”文件可能是程序的源代码，而“www.pudn.com.txt”可能是...
C语言用栈和队列实现的回文检测功能示例
01-20
本文实例讲述了C语言用栈和队列实现的回文功能。分享给大家供大家参考，具体如下： #include #include<malloc>//内存分配头文件 #include<math.h>//在math.h中已定义OVERFLOW的值为3 #define SIZE 100 #...
Java实现栈和队列面试题
09-03
入队操作直接将元素压入入队栈，出队时若出队栈为空，则将入队栈所有元素弹出并压入出队栈，然后从出队栈弹出元素。 4. **两个队列实现一个栈**： 使用两个队列，入栈操作将元素加入第一个队列，出栈时将第二个...
栈的初始化、进栈出栈、清空栈、销毁栈
03-17
栈的初始化、进栈出栈、清空栈、销毁栈，dos输入输出
顺序栈的各种基本操作
03-18
编写一个程序，实现顺序栈的各种基本运算，并在基础上完成以下功能: 1)初始化顺序栈； 2)判断顺序栈是否为空； 3)依次进栈元素a,b,c,d,e； 4)判断顺序栈是否为空； 5)输出栈长度； 6)输出从栈顶到栈底的元素； 7)读出栈顶元素； 8)删除栈顶元素； 9)输出从栈顶到栈底的元素； 10)判断顺序栈是否为空； 11)释放栈。
创建栈的三种形式
05-14
这个Demo主要讲解了,建立Stack的三种形式, 希望可以帮助需要的同学.
栈和队列
qq_44627002的博客
10-10 833
栈和队列 四、存储结构说明和定义： StackInt用来存放操作数和运算结果 StackChar用来存放运算符 typedef struct {//存数字 ElemInt *base; ElemInt *top; int stacksize; }StackInt; typedef struct{//存符号 ElemChar *base; ElemChar *top; int stacksize; }StackChar; 五、主要算法: 给出程序的概要设计或主要算法的程序流程图 采用
队列
qq_42529477的博客
03-30 154
队列的实现 实现代码： #include<bits/stdc++.h> using namespace std; const int N = 100005; string Queue[N]; int head, tail; void enqueue(string name){ Queue[tail++] = name; } string dequeue(){ ...
栈——栈的定义及基本操作（初始化、判空、进栈、出栈、遍历栈、销毁栈等）
热门推荐
薛定谔的猫的博客
04-19 8万+
文章目录栈的定义栈的存储栈上的基本操作初始化判空操作进栈操作出栈操作读栈顶元素遍历栈销毁栈完整代码及实例共享栈 栈的定义 栈（Stack）是只允许在一端进行插入或删除操作的线性表。 栈的示意图： 栈顶Top：线性表允许插入和删除的那一端。 栈底Bottom：固定的，不允许进行插入和删除的另一端。  假设某个栈S={a1,a2, … ,an}，如上图所示，则a1为栈底元素，an为栈顶元素。由于只能在栈顶进行插入和删除操作，故进栈顺序为a1,a2, … ,an，出栈顺序为an, … ,a2,a1。故栈的操
栈的基本操作（C语言实现）创建，销毁，入栈，出栈
m0_74774759的博客
04-22 2087
栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小。
数据结构——栈和队列详细解释
m0_61886762的博客
09-24 2417
你们在使用电脑中也会经历过机器有时会处于疑似死机的状态，鼠标点什么地方都没有任何反应，双击任何快捷键都不动弹。就当你失去内心时，机器突然对你刚的所有操作都执行了一遍。这是因为操作系统在当时可能CPU没有忙过来。操作系统中应用了一种数据结构来实现上述所说的问题也就是先进先出的功能，这就是队列。队列是一种先进先出的线性表简称FIFO。允许插入的操作为队尾，允许删除的操作为队头。就类似于最近几年的做核酸排队的操作，你在入队时是从队尾排队做核酸，做完之后是从队伍的头部做完后退出队伍。
【数据结构】栈的详解
fighting小泽的博客
05-17 2868
栈的结构体其实和顺序表差不多，一个动态开辟的数组，一个栈的容量。注意 top 我们要决定它指向栈顶还是栈顶的下一个元素。如果top初始化为0，则它指向栈顶的下一个元素。如果top初始化为-1，则它指向栈顶元素。我比较喜欢初始化为0，1是top还可以表示元素的个数，可以用来判断栈是否满了。2是插入元素的时候直接在top的位置插入就行，然后再top++即可。这里根据大家喜好设定就行。int top;} ST;
递归设计与C语言实现：栈和队列的应用
"该资源主要介绍了如何使用递归设计算法以及栈和队列的基本概念和应用。通过递归实例展示了如何计算数组中n个元素的和，同时深入讲解了栈的特性、操作以及顺序存储结构。" 在编程中，递归是一种强大的工具，它允许...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值