栈和队列面试题

最新推荐文章于 2024-07-13 17:12:41 发布
最新推荐文章于 2024-07-13 17:12:41 发布
阅读量285 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huaijiu123/article/details/82050423
版权

我们在来看今天的代码之前，相信大家以前可能都封装过栈和队列的基本操作，所以我们在用到一些栈和队列的基本操作的时候，只需要把栈和队列的头文件引进来就可以调用它的一些基本操作的函数，就不用再把那些函数再写一遍了，但在调用栈和队列的头文件的时候，我们必须把栈和队列的头文件和源文件复制到当前这个项目工程底下，不然调不过来。
那我也把栈和队列的那些基本函数给大家放在这吧，便于理解。
Stack.h

#ifndef __STACK_H__
#define __STACK_H__

#include<stdio.h>
#include<assert.h>

#define MaxSize 10

typedef int SDataType;

typedef struct Stack
{
    SDataType _arry[MaxSize];
    int top;//size
}Stack;

void StackInit(Stack* ps);
void StackPush(Stack* ps, SDataType data);
void StackPop(Stack* ps);
int StackSize(Stack* ps);
int StackEmpty(Stack* ps);
void Print(Stack* ps);
SDataType StackTop(Stack* ps);

#endif //__STACK_H__

Stack.c

#include "Stack.h"

void StackInit(Stack* ps)
{
    assert(ps != NULL);
    ps->top = 0;
}

void Print(Stack* ps)
{
    assert(ps != NULL);
    while (ps->top--)
    {
        printf("%d ", ps->_arry[ps->top]);
    }
    printf("\n");
}

void StackPush(Stack* ps, SDataType data)
{
    assert(ps != NULL);
    if (ps->top == MaxSize)
        return;
    else
    {   
        ps->_arry[ps->top] = data;
        ps->top++;
    }
}

void StackPop(Stack* ps)
{
    assert(ps != NULL);
    if (ps->top)
        ps->top--;
}

int StackSize(Stack* ps)
{
    assert(ps != NULL);
    return ps->top;
}

int StackEmpty(Stack* ps)
{
    assert(ps != NULL);
    if (0 == ps->top)
        return 1;
    else
        return 0;
}

SDataType StackTop(Stack* ps)
{
    assert(ps != NULL);
    return ps->_arry[ps->top - 1];
}

Queue.h

#ifndef __QUEUE_H__
#define __QUEUE_H__

#include<stdio.h>
#include<assert.h>
#include<malloc.h>

typedef int QDataType;

typedef struct QListNode
{
    QDataType data;
    struct QListNode* next;
}QListNode;

typedef struct Queue
{
    struct QListNode* Front;
    struct QListNode* Back;
}Queue;

void QueueInit(Queue* q);
void QueuePush(Queue* q, QDataType data);
void QueuePop(Queue* q);
QDataType QueueFront(Queue* q);
QDataType QueueBack(Queue* q);
int QueueSize(Queue* q);
int QueueIsEmpty(Queue* q);
QListNode* BuyQListNode(QDataType data);
void PrintQueue(Queue* q);

#endif //__QUEUE_H__

Queue.c

#include"Queue.h"

void QueueInit(Queue* q)
{
    assert(q);
    QListNode* p = (QListNode*)malloc(sizeof(QListNode));
    if (NULL == p)
    {
        printf("创建结点失败\n");
        return;
    }
    else
    {
        p->data = 0;
        p->next = NULL;
    }
    q->Back = q->Front = p;
}

void PrintQueue(Queue* q)
{
    assert(q);
    QListNode* cur = q->Front;
    while (cur)
    {
        printf("%d--->", cur->data);
        cur = cur->next;
    }
    printf("OVER\n");
}

void QueuePush(Queue* q, QDataType data)
{
    assert(q);
    QListNode* NewNode = BuyQListNode(data);
    q->Back->next = NewNode;
    q->Back = NewNode;
}

void QueuePop(Queue* q)
{
    assert(q);
    QListNode* Del;
    if (q->Back != q->Front)//说明队中有元素，可以删除
    {
        Del = q->Front->next;
        q->Front->next = Del->next;
        if (q->Front->next == q->Back)
        {
            q->Back = q->Front;
            free(Del);
            q->Front->next = NULL;
        }
        else
        {
            free(Del);
        }
    }
}

QDataType QueueFront(Queue* q)
{
    assert(q);
    return q->Front->next->data;
}

QDataType QueueBack(Queue* q)
{
    assert(q);
    return q->Back->data;
}

int QueueSize(Queue* q)
{
    assert(q);
    int count = 0;
    QListNode* cur = q->Front;
    while (cur)
    {
        count++;
        cur = cur->next;
    }
    return count;
}

int QueueIsEmpty(Queue* q)
{
    {
        assert(q);
        if (q->Back == q->Front)//队为空，返回1
            return 1;
        return 0;
    }
}

QListNode* BuyQListNode(QDataType data)
{
    QListNode* NewNode = (QListNode*)malloc(sizeof(QListNode));
    if (NULL == NewNode)
    {
        printf("创建结点失败！\n");
        return;
    }
    NewNode->data = data;
    NewNode->next = NULL;
    return NewNode;
}

1.实现一个栈，要求实现Push(入栈)、Pop(出栈)、Min(返回最小值)的时间复杂度为O(1)
分析：时间复杂度为O(1)，那就是要求我们一次就能找到它的最小值。那我们可以定义两个栈，一个栈专门用来保存它的最小值，等需要的时候我们把保存最小值的这个栈栈顶元素出栈就行。那我们如何让保存最小值的栈的栈顶元素始终是最小值呢，我们就要每次都通过比较更新它的栈顶元素，在第一次的时候，我们让第一个数据同时入两个栈，第二次的时候，我们先让它入数据栈，然后再让第二次入栈的元素与min栈中栈顶元素比较，如果<=min栈的栈顶元素，我们就让它也入min栈，如果大于，则只入到数据栈中，继续取第三个元素，这样min栈的栈顶元素始终都是当前最小的那个值。
这里写图片描述
具体代码如下：
MinStack.h

#ifndef __STACKTOMIN_H__
#define __STACKTOMIN_H__

#define MaxSize 10

#include<stdio.h>
#include<assert.h>
#include "Stack.h"


typedef struct MinStack
{
    Stack _data;
    Stack _min;
}MinStack;

void MinStackInit(MinStack* s);
void MinStackPush(MinStack* s, SDataType data);
void MinStackPop(MinStack* s);
SDataType MinStackTop(MinStack* s);
SDataType MinStackMin(MinStack* s);
int MainSatckSize(MinStack* s);
int IsEmpty(MinStack* s);


#endif //__STACKTOMIN_H__

MinStack.c

#include"MinStack.h"

void MinStackInit(MinStack* s)
{
    assert(s);
    StackInit(&s->_data);
    StackInit(&s->_min);
}

void MinStackPush(MinStack* s, SDataType data)
{
    assert(s);
    StackPush(&s->_data, data);
    if (StackEmpty(&s->_min))//如果min栈为空，说明压入的是第一个元素，把第一个元素也压入min栈中
    {
        StackPush(&s->_min, data);
    }
    else//用压入的数据和min栈栈顶元素比较，若data<min栈顶元素，data压入min栈
    {
        if (data <= StackTop(&s->_min))
        {
            StackPush(&s->_min, data);
        }
    }
}

void MinStackPop(MinStack* s)
{
    assert(s);
    if (StackTop(&s->_data) == StackTop(&s->_min))
    {
        StackPop(&s->_data);
        StackPop(&s->_min);
    }
    StackPop(&s->_data);
}

SDataType MinStackTop(MinStack* s)
{
    assert(s);
    return StackTop(&s->_data);
}

SDataType MinStackMin(MinStack* s)
{
    assert(s);
    return StackTop(&s->_min);
}

int MainSatckSize(MinStack* s)
{
    return StackSize(&s->_data);
}

int IsEmpty(MinStack* s)
{
    return StackEmpty(&s->_data);
}

test.c

#include"MinStack.h"

int main()
{
    MinStack s;
    MinStackInit(&s);
    MinStackPush(&s, 1);
    MinStackPush(&s, 2);
    MinStackPush(&s, 3);
    MinStackPush(&s, 4);
    printf("top = %d\n", MinStackTop(&s));
    printf("size = %d\n", MainSatckSize(&s));
    printf("min = %d\n", MinStackMin(&s));

    MinStackPop(&s);
    MinStackPush(&s, 0);
    MinStackPush(&s, 4);
    printf("top = %d\n", MinStackTop(&s));
    printf("size = %d\n", MainSatckSize(&s));
    printf("min = %d\n", MinStackMin(&s));

    return 0;
}

运行结果正确：
这里写图片描述
2.使用两个栈实现一个队列
分析：
这里写图片描述
在把元素从一个栈导入另一个栈的时候，我们每次要把这个栈的栈顶元素入到另一个栈去，然后这个栈的栈顶元素出栈，依次进行，直到这个栈为空，我们就把这个栈的元素完全导入到另一个栈中了。

我们来看看具体代码实现
QueueBy2Stack.h

#ifndef __QUEUEBY2STACK_H__
#define __QUEUEBY2STACK_H__

#include<stdio.h>
#include<assert.h>
#include"Stack.h"

#define MaxSize 10

typedef struct Queue
{
    Stack s1;
    Stack s2;
}Queue;

void QueueBy2StackPush(Queue* q, SDataType data);
void QueueBy2StackPop(Queue* q);
SDataType QueueBy2StackTop(Queue* q);
SDataType QueueBy2StackBack(Queue* q);
int QueueBy2StackSize(Queue* q);
int IsQueueBy2StackEmpty(Queue* q);

#endif //__QUEUEBY2STACK_H__

QueueBy2Stack.c

#include"QueueBy2Stack.h"

void InitQueueBy2Stack(Queue* q)
{
    assert(q);
    StackInit(&q->s1);
    StackInit(&q->s2);
}

void QueueBy2StackPush(Queue* q, SDataType data)
{
    assert(q);
    StackPush(&q->s1, data);
}

void QueueBy2StackPop(Queue* q)
{
    assert(q);
    if (!StackEmpty(&q->s2))
    {
        StackPop(&q->s2);
    }
    else
    {
        while (!StackEmpty(&q->s1))
        {
            StackPush(&q->s2, StackTop(&q->s1));
            StackPop(&q->s1);
        }
        StackPop(&q->s2);
    }
}

SDataType QueueBy2StackTop(Queue* q)
{
    assert(q);
    if (!StackEmpty(&q->s2))
    {
        return StackTop(&q->s2);
    }
    else
    {
        while (!StackEmpty(&q->s1))
        {
            StackPush(&q->s2, StackTop(&q->s1));
            StackPop(&q->s1);
        }
        return StackTop(&q->s2);
    }
}

SDataType QueueBy2StackBack(Queue* q)
{
    assert(q);
    if (!StackEmpty(&q->s1))
    {
        return StackTop(&q->s1);
    }
    else
    {
        while (!StackEmpty(&q->s2))
        {
            StackPush(&q->s1, StackTop(&q->s2));
            StackPop(&q->s2);
        }
        return StackTop(&q->s1);
    }
}

int QueueBy2StackSize(Queue* q)
{
    assert(q);
    return StackSize(&q->s1) + StackSize(&q->s2);
}

int IsQueueBy2StackEmpty(Queue* q)
{
    assert(q);
    return StackEmpty(&q->s1) && StackEmpty(&q->s2);//1---是空
}

test.c

#include"QueueBy2Stack.h"

int main()
{
    Queue q;
    InitQueueBy2Stack(&q);
    QueueBy2StackPush(&q, 1);
    QueueBy2StackPush(&q, 2);
    QueueBy2StackPush(&q, 3);
    printf("Size = %d\n", QueueBy2StackSize(&q));
    printf("Front = %d\n", QueueBy2StackTop(&q));
    printf("Back = %d\n", QueueBy2StackBack(&q));

    QueueBy2StackPop(&q);
    printf("Size = %d\n", QueueBy2StackSize(&q));
    printf("Front = %d\n", QueueBy2StackTop(&q));
    printf("Back = %d\n", QueueBy2StackBack(&q));

    QueueBy2StackPush(&q, 4);
    QueueBy2StackPush(&q, 5);
    printf("Size = %d\n", QueueBy2StackSize(&q));
    printf("Front = %d\n", QueueBy2StackTop(&q));
    printf("Back = %d\n", QueueBy2StackBack(&q));

    return 0;
}

运行结果正确：
这里写图片描述
3.使用两个队列实现一个栈
分析：
这里写图片描述
我们来看看具体代码实现吧：
StackBy2Queue.h

#ifndef __STACKBY2QUEUE_H__
#define __STACKBY2QUEUE_H__

#include"Queue.h"

typedef struct StackBy2Queue
{
    Queue q1;
    Queue q2;
}StackBy2Queue;

void StackBy2QueueInit(StackBy2Queue* q);
void StackBy2QueuePush(StackBy2Queue* q, QDataType data);
void StackBy2QueuePop(StackBy2Queue* q);
QDataType StackBy2QueueTop(StackBy2Queue* q);
int StackBy2QueueSize(StackBy2Queue* q);
int StackBy2QueueEmpty(StackBy2Queue* q);


#endif //__STACKBY2QUEUE_H__

StackBy2Queue.c

#include"StackBy2Queue.h"

void StackBy2QueueInit(StackBy2Queue* q)
{
    assert(q);
    QueueInit(&q->q1);
    QueueInit(&q->q2);
}

void StackBy2QueuePush(StackBy2Queue* q, QDataType data)
{
    assert(q);
    if (!QueueIsEmpty(&q->q1))//队1中有数据
    {
        QueuePush(&q->q1, data);
    }
    else//队2中有数据或两个队都为空
    {
        QueuePush(&q->q2, data);
    }
}

void StackBy2QueuePop(StackBy2Queue* q)
{
    assert(q);
    if (!QueueIsEmpty(&q->q1))//队1中有数据
    {
        while (QueueSize(&q->q1)>2)//因为带有头结点，是所以是>2
        {
            QueuePush(&q->q2, QueueFront(&q->q1));
            QueuePop(&q->q1);
        }
        QueuePop(&q->q1);
    }
    else
    {
        while (QueueSize(&q->q2)>2)//因为带有头结点，是所以是>2
        {
            QueuePush(&q->q1, QueueFront(&q->q2));
            QueuePop(&q->q2);
        }
        QueuePop(&q->q2);
    }
}

QDataType StackBy2QueueTop(StackBy2Queue* q)
{
    assert(q);
    if (!QueueIsEmpty(&q->q1))
    {
        return QueueBack(&q->q1);
    }
    else
    {
        return QueueBack(&q->q2);
    }
}

int StackBy2QueueSize(StackBy2Queue* q)
{
    assert(q);
    return QueueSize(&q->q1) + QueueSize(&q->q2) - 1;
}

int StackBy2QueueEmpty(StackBy2Queue* q)
{
    if (2 == QueueSize(&q->q1) + (QueueSize(&q->q2)))
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

运行结果正确：
这里写图片描述
4.元素出栈入栈顺序的合法性。如入栈的序列(1，2，3，4，5)，出栈序列为(4，5，3，2，1)
分析：这里写图片描述

我们来看看具体代码实现：
IsStackValidOrder.h

#ifndef __ISSTACKVALIDORDER_H__
#define __ISSTACKVALIDORDER_H__

#include"Stack.h"

int IsStackValidOrder(int* InArr, int InSize, int* OutArr, int OutSize);

#endif //__ISSTACKVALIDORDER_H__

IsStackValidOrder.c

#include"IsStackValidOrder.h"

int IsStackValidOrder(int* InArr, int InSize, int* OutArr, int OutSize)
{
    int inIdx = 0;
    int outIdx = 0;
    Stack s;
    StackInit(&s);
    if (OutSize != InSize)
    {
        return 0;
    }
    while (outIdx < OutSize)
    {
        if (inIdx>=InSize)
        {
            return;
        }
        else
        {
            while (StackEmpty(&s) || OutArr[outIdx] != StackTop(&s))
            {
                StackPush(&s, InArr[inIdx++]);
            }
            StackPop(&s);
            outIdx++;
        }
    }
    return 1;
}

test.c

#include"IsStackValidOrder.h"

int main()
{
    int InArr[] = { 1, 2, 3, 4, 5 };
    int OutArr[] = { 4, 5, 3, 1, 2 };
    int ret = 0;
    ret = IsStackValidOrder(InArr, 5, OutArr, 5);
    if (1 == ret)
    {
        printf("匹配成功\n");
    }
    else
    {
        printf("匹配失败\n");
    }

    return 0;
}

运行结果正确：
这里写图片描述
5.一个数组实现两个栈(共享栈)。
分析：
这里写图片描述
具体代码：
SharedStack.h

#ifndef __SHAREDSTACK_H__
#define __SHAREDSTACK_H__

#include<stdio.h>
#include<assert.h>

typedef int SDataType;

#define MaxSize 10

typedef struct SharedStack
{
    SDataType arry[MaxSize];
    int top1;
    int top2;
}SharedStack;

void SharedStackInit(SharedStack* ps);
void SharedStackPush(SharedStack* ps, SDataType data, int which);
void SharedStackPop(SharedStack* ps, int which);
int SharedStackSize(SharedStack* ps);

#endif //__SHAREDSTACK_H__

SharedStack.c

#include"SharedStack.h"

void SharedStackInit(SharedStack* ps)
{
    assert(ps);
    int i = 0;
    for (i = 0; i < MaxSize; i++)
    {
        ps->arry[i] = 0;
    }
    ps->top1 = 0;
    ps->top2 = MaxSize - 1;
}

void SharedStackPush(SharedStack* ps, SDataType data, int which)
{
    assert(ps);
    if (ps->top1 > ps->top2)
    {
        return;
    }
    else
    {
        if (1 == which)
        {
            ps->arry[ps->top1++] = data;
        }
        else
        {
            ps->arry[ps->top2--] = data;
        }
    }
}


void SharedStackPop(SharedStack* ps, int which)
{
    assert(ps);
    if (0 == ps->top1  && ps->top2 == MaxSize - 1)//如果栈里没有元素，不要出栈
    {
        return;
    }
    else
    {
        if (1 == which)
        {
            ps->top1--;
        }
        else
        {
            ps->top2++;
        }
    }
}

test.c

#include"SharedStack.h"

int main()
{
    SharedStack s;
    SharedStackInit(&s);
    SharedStackPush(&s, 1, 1);
    SharedStackPush(&s, 2, 1);

    SharedStackPush(&s, 6, 2);
    SharedStackPush(&s, 7, 2);
    SharedStackPop(&s, 2);

    return 0;
}

运行结果：
这里写图片描述

。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。

人山人海肉最可爱
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
栈和队列的面试题
小葱的博客
07-13 1046
1.实现一个栈，要求实现Push（出栈）、Pop（入栈）、Min（返回最小值的操作）的时间复杂度为O(1)对于这个问题，我们都知道，栈的入栈和出栈时间复杂度都是O(1),那么我们所面临的问题就是需要有一个接口来实现返回最小值的操作，且这个操作的时间复杂度必须是O(1)。 这里有两种思路可供选择： （1）前提：这里有一组数据，利用一个栈，将这些数据需要入栈，而在入栈的时候遵循这样的规律，将一个数据
Java实现栈和队列面试题
09-03
以上就是Java实现栈和队列面试题的主要内容。理解和熟练掌握这些知识点对于Java开发者来说至关重要，因为它们涉及到基础数据结构的运用，能够反映候选人在解决实际问题时的逻辑思维和算法能力。在面试中，候选人可能...
栈与队列面试题
sifanchao的博客
06-08 321
实现一个栈，要求实现Push（入栈）、Pop（出栈）、Min（返回最小值）的时间复杂度为O(1) 思路： 定义两个栈，一个栈（st）进行入栈出栈操作，一个栈(minst)放当前最小值。那么什么时候更新最小栈数据呢？有两种情况： 1.当最小栈为空栈时，将此时压栈st的数据拷贝到最小栈里。 2.如果当前最小栈的数据&amp;gt;=压栈的数据，满足条件时，进行数据拷贝。 ...
栈和队列(Stack & Queue)
最新发布
qq_57146327的博客
07-13 763
T data;
3栈和队列面试题精讲.ppt
07-31
3栈和队列面试题精讲
栈——经典面试题
10-14
本题目的核心在于如何利用两个栈来模拟一个队列，这是《剑指Offer》这本书中的一道经典面试题，旨在测试候选人在实际问题中应用数据结构的能力。 首先，我们需要理解栈和队列的基本操作。栈的主要操作有压入（push...
360架构师 分享 超详细大厂程序员高频面试题-如何用栈实现队列
09-20
360架构师 分享 超详细大厂程序员高频面试题-如何用栈实现队列 站台巨人肩膀上，弯道超车，秒杀面试官
（剑指offer）面试题09. 用两个栈实现队列
12-21
在本题中，我们需要使用两个栈来模拟队列的行为。 题目要求我们实现一个类`CQueue`，它有两个主要方法：`appendTail`用于在队列尾部插入元素，`deleteHead`用于从队列头部删除元素并返回该元素。如果队列为空，`...
栈和队列相关面试题
一朵花花
10-03 825
前言： 上篇文章介绍了栈和队列及其相关操作，本篇通过几个面试题，来进一步掌握栈和队列~ 目录括号匹配问题用队列实现栈用栈实现队列实现一个最小栈设计一个循环队列 括号匹配问题 题目：在线OJ 用队列实现栈 题目：在线OJ 用栈实现队列 题目：在线OJ 实现一个最小栈 题目：在线OJ 设计一个循环队列 题目： 在线OJ ...
栈和队列的面试题(一)
virgofarm的博客
05-04 252
一：实现一个栈，要求实现Push(出栈)、Pop(入栈)、Min(返回最小值)的时间复杂度为O(1) 方法一： 思路：这里我们栈底层采用的是静态顺序表实现，出栈、入栈我们都很容易实现时间复杂度为O(1)，但是，要返回最小值，按照我们常规的思路，遍历栈，可以得出最小值，但是时间复杂度为O(n),不符合题目要求，我们可以在栈中每次放入两个数据，一个是本来就要放的data,另一个为Mindata...
面试题----栈和队列
倔强的瓶盖儿的博客
06-26 162
系列文章目录 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录系列文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 根据上一文章的集合简要的 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤
栈和队列的相关面试题（详解）
baidu_37964044的博客
04-09 406
#include&lt;iostream&gt; #include&lt;stack&gt; #include&lt;queue&gt; using namespace std; //实现一个栈，要求实现Push（入栈） Pop（出栈） Min（返回最小值的操作） 时间复杂度为O(1) //方法一：用两个栈实现，先同时往s1,和min里面入第一个元素，接着s1正常入,同时_min入的时候用s1栈顶...
栈与队列面试题解析：从基础到高级应用
"3栈和队列面试题精讲.ppt" 这篇内容主要讲解了与栈和队列相关的面试题目，并提供了详细的解题思路。栈和队列是两种基础且重要的线性数据结构，它们在算法和数据结构领域扮演着至关重要的角色。 线性表是一种简单...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值