栈和队列面试题总结

最新推荐文章于 2024-05-09 17:00:00 发布
最新推荐文章于 2024-05-09 17:00:00 发布
阅读量1.1k 收藏 6
点赞数 1
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hansionz/article/details/81636768
版权

栈的基础操作
https://blog.csdn.net/hansionz/article/details/81636557
队列的基础操作
https://blog.csdn.net/hansionz/article/details/81636644

栈和队列面试题（c语言实现）

1.实现一个栈，要求实现Push(入栈)、Pop(出栈)、Min(返回最小值)的时间复杂度为O(1).
2.使用两个栈实现一个队列
3.使用两个队列实现一个栈
4.元素出栈、入栈的合法性。如入栈的序列(1,2,3,4,5),出栈序列为(4,5,3,2,1)
5.一个数组实现两个共享栈

1.实现一个栈，要求实现Push(入栈)、Pop(出栈)、Min(返回最小值)的时间复杂度为O(1).

思路：
这里写图片描述

/**************************************************************/
//1.获取最小值(O(1))
typedef struct GetMinStack
{
    Stack _mst;//存放正常入栈序列
    Stack _msmin;//存放最小值
}GetMinStack;

//入栈操作
void Stack_O1Push(GetMinStack* ps, DataType x);
//出栈操作
void Stack_O1Pop(GetMinStack* ps);
//获取最小值
DataType GetMinValue(GetMinStack* ps);
//取栈顶元素
DataType GetStack_O1Top(GetMinStack* ps);

void Stack_O1Push(GetMinStack* ps, DataType x)
{
    assert(ps);
    //存放数据的栈无论如何必须压栈
    StackPush(&ps->_mst, x);
    //如果存放最小值那个栈栈顶元素大于x或者是那个栈还为空，必须压栈
    if ((StackTop(&ps->_msmin) > x) || (StackEmpty(&ps->_msmin) == 0))
    {
        StackPush(&ps->_msmin, x);
    }
}
void Stack_O1Pop(GetMinStack* ps)
{
    assert(ps);
    //比较两个栈顶元素是否相同，如果相同都出栈，如果不相同，只出数据栈
    if (StackTop(&ps->_mst) == StackTop(&ps->_msmin))
    {
        StackPop(&ps->_msmin);
    }
    StackPop(&ps->_mst);
}
DataType GetMinValue(GetMinStack* ps)
{
    assert(ps);
    return StackTop(&ps->_msmin);
}
DataType GetStack_O1Top(GetMinStack* ps)
{
    assert(ps);
    return StackTop(&ps->_mst);
}
2.使用两个栈实现一个队列

思路：
这里写图片描述

typedef struct QueueBy2Stack
{
    Stack input;//实现入队的栈
    Stack output;//实现出队的栈
}QueueBy2Stack;

//初始化函数
void QueueInit(QueueBy2Stack* pq);
//销毁函数
void QueueDestroy(QueueBy2Stack* pq);
//入队函数
void QueuePush(QueueBy2Stack* pq, DataType x);
//出队函数
void QueuePop(QueueBy2Stack* pq);
//取队头元素函数
DataType QueueFront(QueueBy2Stack*pq);
//求队列大小
int QueueSize(QueueBy2Stack* pq);
//判断队列是否为空,空返回0，非空返回1
int QueueEmpty(QueueBy2Stack* pq);

/****************************************************************/
/*两个栈实现一个队列*/
void QueueInit(QueueBy2Stack* pq)
{
    assert(pq);
    StackInit(&pq->input);
    StackInit(&pq->output);
}
void QueueDestroy(QueueBy2Stack* pq)
{
    assert(pq);
    StackDestroy(&pq->input);
    StackDestroy(&pq->output);
}
void QueuePush(QueueBy2Stack* pq, DataType x)
{
    assert(pq);
    //把output栈所有元素拿到input栈
    while (StackEmpty(&pq->output))
    {
        DataType tmp;
        tmp = StackTop(&pq->output);
        StackPop(&pq->output);
        StackPush(&pq->input, tmp);
    }
    //然后入栈既入队
    StackPush(&pq->input, x);
}
void QueuePop(QueueBy2Stack* pq)
{
    assert(pq);
    //把input栈所有元素拿到output栈
    while (StackEmpty(&pq->input))
    {
        DataType tmp;
        tmp = StackTop(&pq->input);
        StackPop(&pq->input);
        StackPush(&pq->output, tmp);
    }
    //然后出栈相当于出队
    StackPop(&pq->output);
}
DataType QueueFront(QueueBy2Stack*pq)
{
    assert(pq);
    while (StackEmpty(&pq->input))
    {
        DataType tmp;
        tmp = StackTop(&pq->input);
        StackPop(&pq->input);
        StackPush(&pq->output, tmp);
    }
    //和pop一样只不过这里变成取栈顶
    return StackTop(&pq->output);
}
int QueueSize(QueueBy2Stack* pq)
{
    assert(pq);

    return StackSize(&pq->input) + StackSize(&pq->output);
}
//空返回0，非空返回1
int QueueEmpty(QueueBy2Stack* pq)
{
    assert(pq);

    return StackEmpty(&pq->input) | StackEmpty(&pq->output);
}
3.使用两个队列实现一个栈

思路：
这里写图片描述

typedef struct StackBy2Queue
{
    Queue queue1;
    Queue queue2;
    int size;//有效元素的个数
}StackBy2Queue;

//初始化函数
void StackInit(StackBy2Queue* ps);
//销毁函数
void StackDestroy(StackBy2Queue* ps);
//入栈操作函数
void StackPush(StackBy2Queue* ps, DataType x);
//出栈操作函数
void StackPop(StackBy2Queue* ps);
//取栈顶元素函数
DataType StackGetTop(StackBy2Queue* ps);
//求栈的大小
int StackSize(StackBy2Queue* ps)
//判断栈是否为空，空返回0，非空返回1
int StackEmpty(StackBy2Queue* ps)
/***************************************************************/
/*两个队列实现一个栈*/
//初始化栈
void StackInit(StackBy2Queue* ps)
{
    assert(ps);
    QueueInit(&ps->queue1);
    QueueInit(&ps->queue2);
    ps->size = 0;
}
//销毁栈
void StackDestroy(StackBy2Queue* ps)
{
    assert(ps);
    QueueDestroy(&ps->queue1);
    QueueDestroy(&ps->queue2);
    ps->size = 0;
}
//入栈操作
void StackPush(StackBy2Queue* ps, DataType x)
{
    assert(ps);
    //两个队列都为空，插入哪一个都行，有一个队列不为空，就插入那个队列
    if (QueueSize(&ps->queue1) != 0)
    {
        QueuePush(&ps->queue1, x);
    }
    else
    {
        QueuePush(&ps->queue2, x);
    }
    ps->size++;
}
//出栈操作
void StackPop(StackBy2Queue* ps)
{
    assert(ps);
    //空栈
    if (ps->size == 0)
    {
        return;
    }
    //确定那个队列为空，那个不为空
    Queue* _Have = &ps->queue1;//有元素
    Queue* _NoHave = &ps->queue2;//没有元素

    if (QueueSize(&ps->queue1) == 0)
    {
        _Have = &ps->queue2;
        _NoHave = &ps->queue1;
    }
    //不为空的队列保留一个元素，最后出队既是出栈
    while (QueueSize(_Have)!=1)
    {
        DataType tmp;
        tmp = QueueFront(_Have);
        QueuePop(_Have);
        QueuePush(_NoHave, tmp);
    }
    QueuePop(_Have);
    ps->size--;
}
//取栈顶元素
DataType StackGetTop(StackBy2Queue* ps)
{
    assert(ps);
    //空栈
    if (ps->size == 0)
    {
        return;
    }
    Queue* _Have = &ps->queue1;//有元素
    Queue* _NoHave = &ps->queue2;//没有元素

    if (QueueSize(&ps->queue1) == 0)
    {
        _Have = &ps->queue2;
        _NoHave = &ps->queue1;
    }
    //直接返回队尾元素或者是下面的做法(移到另一个队列，取队头)
    return QueueBack(_Have);
#if 0
    while (QueueSize(_Have) != 1)
    {
        DataType tmp;
        tmp = QueueFront(_Have);
        QueuePop(_Have);
        QueuePush(_NoHave, tmp);
    }
    DataType cur = QueueFront(_Have);
    QueuePop(_Have);
    QueuePush(_NoHave, cur);
    return cur;
#endif
}
int StackSize(StackBy2Queue* ps)
{
    assert(ps);
    return QueueSize(&ps->queue1) + QueueSize(&ps->queue2);
}
//空 返回0，非空返回1
int StackEmpty(StackBy2Queue* ps)
{
    assert(ps);
    return QueueEmpty(&ps->queue1) | QueueEmpty(&ps->queue2);
}
4.元素出栈、入栈的合法性。如入栈的序列(1,2,3,4,5),出栈序列为(4,5,3,2,1)

思路：
这里写图片描述

/*************************************************************/
/*检查出入栈的合法性，合法返回1，不合法返回0*/
int CheckLegal(int* num_in, int* num_out,int len_in,int len_out)
{
    Stack s;
    StackInit(&s);
    //如果两个出入栈序列长度不相同必然不合法
    if (len_in != len_out)
    {
        return 0;
    }
    assert(num_in);
    assert(num_out);
    int j = 0;
    for (int i = 0; i < len_in; i++)
    {
        StackPush(&s, num_in[i]);
        //栈顶元素和出栈序列相同则出栈一次，出栈序列向后移动一位
        //不相同则继续入栈入栈序列
        while ((StackEmpty(&s) != 0) && (StackTop(&s) == num_out[j]))
        {
            StackPop(&s);
            j++;
        }
    }
    return StackEmpty(&s) == 0 ? 1 : 0;
}
5.一个数组实现两个共享栈

思路：
这里写图片描述
第一种用于有缺陷，这里就不实现了。只实现第二种和第三种方式。

第二种实现方式：

#define MAXSIZE 10
typedef struct StackShare
{
    DataType* _a;
    int top_low;//左栈栈顶
    int top_high;//右栈栈顶
}StackShare;
//初始化栈
void StackShareInit(StackShare* ps);
//销毁栈
void StackShareDestroy(StackShare* ps);
//检查栈是否满
int StackIsFull(StackShare* ps);
//检查共享栈是否为空
int StackShareEmpty(StackShare* ps, char c);
//求栈的大小
int StackShareSize(StackShare* ps, char c);
//入栈操作
void StackSharePush(StackShare* ps, DataType x, char c);
//出栈操作
void StackSharePop(StackShare* ps, char c);
//取栈顶元素
DataType StackShareTop(StackShare* ps, char c);
/***************************************************************/
/*共享栈,‘L’代表左栈，‘R’代表右栈(静态实现)*/
//初始化栈
void StackShareInit(StackShare* ps)
{
    assert(ps);
    memset(ps->_a, sizeof(DataType)*MAXSIZE, 0);
    ps->top_high = MAXSIZE - 1;
    ps->top_low = 0;
}
//销毁栈
void StackShareDestroy(StackShare* ps, char c)
{
    assert(ps);
    assert((c == 'R' || (c == 'L')));
    if (c == 'L')
    {
        ps->top_low = 0;
    }
    else
    {
        ps->top_high = 0;
    }
}
//判断栈是否为空，空返回0，非空返回1
int StackShareEmpty(StackShare* ps, char c)
{
    assert(ps);
    assert((c == 'R' || (c == 'L')));
    //左栈
    if (c == 'L')
    {
        return ps->top_low == 0 ? 0 : 1;
    }
    //右栈
    else
    {
        return ps->top_high == MAXSIZE - 1 ? 0 : 1;
    }
}
//栈的大小
int StackShareSize(StackShare* ps, char c)
{
    assert(ps);
    assert((c == 'R' || (c == 'L')));
    if (c == 'L')
    {
        return ps->top_low;
    }
    else 
    {
        return MAXSIZE - 1 - ps->top_high;
    }
}
//入栈
void StackSharePush(StackShare* ps, DataType x, char c)
{
    assert(ps);
    assert((c == 'R' || (c == 'L')));
    if (StackIsFull(ps))
    {
        printf("StackFull\n");
        return;
    }
    if (c == 'L')
    {
        ps->_a[ps->top_low] = x;
        ps->top_low++;
    }
    else
    {
        ps->_a[ps->top_high] = x;
        ps->top_high--;
    }
}
//出栈
void StackSharePop(StackShare* ps, char c)
{
    assert(ps);
    assert((c == 'R' || (c == 'L')));
    if (c == 'L')
    {
        if (StackShareEmpty(ps, c))
        {
            ps->top_low--;
        }
        else
        {
            printf("StackEmpty\n");
        }
    }
    else
    {
        if (StackShareEmpty(ps, c))
        {
            ps->top_high++;
        }
        else
        {
            printf("StackEmpty\n");
        }
    }
}
//取栈顶元素
DataType StackShareTop(StackShare* ps, char c)
{
    assert(ps);
    assert((c == 'R' || (c == 'L')));
    if (c == 'L')
    {
        return ps->_a[ps->top_low - 1];
    }
    else
    {
        return ps->_a[ps->top_high + 1];
    }
}
//判断栈是否满，满返回1，不满返回0
int StackIsFull(StackShare* ps)
{
    assert(ps);
    if (ps->top_low <= ps->top_high)
    {
        return 0;
    }
    else
    {
        return 1;
    }
}

第二种实现方式（奇偶栈）：

/******************************************************/
/*5.一个数组实现一个共享栈(奇偶栈)*/
//初始化共享栈(动态实现)
void ShareStackInit(ShareStack* ps)
{
    assert(ps);
    ps->_a = (DataType*)malloc(sizeof(DataType)* 3);
    ps->_top_l = 0;
    ps->_top_r = 1;
    ps->capacity = 3;
}
//销毁共享栈
void ShareStackDestroy(ShareStack* ps, char c)
{
    assert(ps);
    assert(c == 'L' || c == 'R');
    if (c == 'L')
    {
        ps->_top_l = 0;
        if (ps->_top_r == 1)
        {
            free(ps->_a);
            ps->_a = NULL;
            ps->capacity = 0;
        }
    }
    else
    {
        ps->_top_r = 1;
        if (ps->_top_l == 0)
        {
            free(ps->_a);
            ps->_a = NULL;
            ps->capacity = 0;
        }
    }
}
//入栈
void ShareStackPush(ShareStack* ps, DataType x, char c)
{
    assert(ps);
    assert(c == 'L' || c == 'R');
    if (c == 'L')
    {
        if (ps->_top_l >= ps->capacity)
        {
            DataType* tmp = realloc(ps->_a, (sizeof(DataType)*  (2 * ps->capacity)));
            if (tmp != NULL)
            {
                ps->_a = tmp;
            }
            ps->capacity *= 2;
        }
        ps->_a[ps->_top_l] = x;
        ps->_top_l += 2;
    }
    else
    {
        if (ps->_top_r >= ps->capacity)
        {
            DataType* tmp = realloc(ps->_a, 2 * (ps->capacity));
            if (tmp != NULL)
            {
                ps->_a = tmp;
            }
            ps->capacity *= 2;
        }
        ps->_a[ps->_top_r] = x;
        ps->_top_r += 2;
    }
}
//出栈
void ShareStackPop(ShareStack* ps, char c)
{
    assert(ps);
    assert(c == 'L' || c == 'R');
    if (c == 'L')
    {
        if (ps->_top_l == 0)
        {
            printf("StackEmpty\n");
            return;
        }
        ps->_top_l -= 2;
    }
    else
    {
        if (ps->_top_r == 0)
        {
            printf("StackEmpty\n");
            return;
        }
        ps->_top_r -= 2;
    }
}
取栈顶元素
DataType ShareStackTop(ShareStack* ps, char c)
{
    assert(ps);
    assert(c == 'L' || c == 'R');
    if (c == 'L')
    {
        return ps->_a[ps->_top_l - 2];
    }
    else
    {
        return ps->_a[ps->_top_r - 2];
    }
}
//为空返回0，非空返回1
int ShareStackEmpty(ShareStack* ps, char c)
{
    assert(ps);
    assert(c == 'L' || c == 'R');
    if (c == 'L')
    {
        return ps->_top_l == 0 ? 0 : 1;
    }
    else
    {
        return ps->_top_r == 1 ? 0 : 1;
    }
}
//求栈的大小
int ShareStackSize(ShareStack* ps, char c)
{
    assert(ps);
    assert(c == 'L' || c == 'R');
    if (c == 'L')
    {
        return ps->_top_l / 2;
    }
    else
    {
        return ps->_top_r / 2;//向下取整
    }
}
Hansionz
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构——栈与队列
m0_57484470的博客
10-17 6317
数据结构栈与队列相关基础知识详解！！！
数据结构—栈和队列经典面试题
3166375975@的博客
09-21 8714
栈和队列面试题： 实现一个栈，要求实现Push(出栈)、Pop(入栈)、Min(返回最小值)的时间复杂度为O(1) 使用两个栈实现一个队列 使用两个队列实现一个栈 元素出栈、入栈顺序的合法性。如入栈的序列(1,2,3,4,5)，出栈序列为 (4,5,3,2,1) 一个数组实现两个栈(共享栈) 实现一个栈，要求实现Push(出栈)、Pop(入栈)、Min(返回最小值)的时间复杂度为O...
数据结构----栈和队列
喜欢编写一些小程序的科班菜鸟，但是由于准备考研，博客不能及时更新了，不好意思！
05-19 1452
栈篇 1.1栈 栈，线性表的一种特殊的存储结构。与学习过的线性表的不同之处在于栈只能从表的固定一端对数据进行插入和删除操作，另一端是封死的。由于栈只有一边开口存取数据，称开口的那一端为“栈顶”，封死的那一端为“栈底”（类似于盛水的木桶，从哪进去的最后还得从哪出来）。 1.2.栈操作数据元素的两种动作： 数据元素用栈的数据结构存储起来，称为“入栈”，也叫“压栈”。 数据元素由于某种原因需要从栈结构中提取出来，称为“出栈”，也叫“弹栈”。 注意：栈遵循先进后出原则 1.3.栈的表示方式 既然栈
【数据结构】栈(Stack)和队列(Queue)
最新发布
炸掉地球的博客
05-09 1856
栈和队列都是一种特殊的线性表。栈的特点：后进先出，只能在表尾进行插入和删除。队列的特点：先进先出，只能在表头删除，在表尾插入。它们都可以用顺序存储和链式存储的方式。栈常用顺序存储结构即数组的方式，因为数组的尾插尾删效率高，但可能会存在频繁开辟内存空间和内存空间浪费的问题。而栈的链式存储结构，解决了空间浪费的问题，但每个节点都存放一个指针域，也会存在一定的内存开销，并且在每次申请和释放节点的过程中也存在一定的时间开销。队列常用链式存储结构即链表的方式，
【数据结构】栈和队列详细分析（全）
码农研究僧的博客
05-05 1万+
前言 栈和队列是两种重要的线性结构。从数据结构角度看，栈和队列也是线性表， 其特殊性在于栈和队列的基本操作是线性表操作的子集，它们是操作受限的线性表，因此，可称为限定性的数据结构。 栈的定义与特点 栈是限定仅在表尾进行插入或删除操作的线性表。 表尾称为栈顶,表头端称为栈底 。不含元素的空表称为空栈。栈的修改是按后进先出的原则进行的。 栈的操作 队列的定义与特点 和栈相反，队列是一种先进先出的线性表。它只允许在表的一端进行插入，而在另一端删除元素，允许插入的一端称为队尾，允许删除的一端则称为队头。 ...
栈和队列的经典例题（括号匹配，用栈实现队列，用队列实现栈，设计循环队列）
身在边城 心在编程
04-19 375
栈和队列的基础接口实现 链接：https://blog.csdn.net/qq_43763344/article/details/89386829 .============================================================ 头文件： #include <iostream> #include <stdio.h> #include...
c++面试题总结.zip
01-20
这份"C++面试题总结.zip"文件显然是为准备C++职位面试者精心编排的资料集合，它涵盖了从基础到高级的诸多主题，旨在帮助程序员提升自己的技能，顺利通过大厂的选拔。下面我们将深入探讨其中可能涉及的知识点。 首先...
C++一些面试题总结.zip
01-20
这份"C++一些面试题总结.zip"文件显然是为准备C++面试或提升C++技能的程序员精心准备的资料集。它涵盖了从基础到高级的各种知识点，旨在帮助开发者在面对大厂面试时能够得心应手。 一、C++面试常问题 C++面试通常会...
JAVA最新面试题总结
02-08
例如，对于JVM性能优化，面试者应了解如何分析堆内存、栈内存的使用，以及如何调整JVM参数以提升应用性能。对于分布式实战，理解微服务架构、负载均衡、分布式缓存、消息队列等概念和技术是必要的。 总之，Java...
iOS各类面试题总结.zip
07-08
这份名为"IOS各类面试题总结.zip"的压缩包文件包含了针对iOS开发者的全面面试准备资料。其中涵盖了多个知名互联网大厂如字节跳动、美团、腾讯和百度的面试题目，旨在帮助iOS开发者提升技能，顺利通过面试，实现职业...
栈与队列面试题
lucky52529的博客
01-08 301
下面是这5道题c语言实现的源代码 bool isValid(char* s)//判断括号是否有效 { int len = strlen(s); int pos = 0; int* ans = (int*)malloc(sizeof(int)*len); for (int i = 0; i &amp;lt; len; i++) { if ((s[i] == '(') || (s[i] == ...
面试题:栈和队列的区别？
yeliner的博客
03-29 1296
从定义上： 栈：是一端进行插入和删除（开口的），另一端是封闭的特殊的线性表。 队列：在一端进行插入，在另一端进行删除的线性表。 从运算上： 栈：指针top（栈顶），bottom（栈底）；插入入栈运算（top+1），删除退栈运算(top-1)。 队列：指针rear（队尾），front（排头）；在队尾插入入列运算（尾指针进1，当rear=m+1时，rear=1），排头删除退队运算(排头指针进1
队列与栈面试题C++
开贰锤
11-09 545
概念 1.图的深度优先遍历（DFS） 可以用栈实现，从根结点开始沿左孩子到最深的节点压入栈中，然后依次弹出，若栈顶节点还有没有访问的孩子，则没访问过得孩子入栈直到最深的节点，然后再弹出。元素入栈顺序则为深度优先遍历顺序。 2.图的宽度优先遍历（BFS） 可以用队列实现，将根结点放入队列，每弹出一个节点，就将该节点的孩子全部放入队列，放入队列的顺序为宽度优先遍历顺序。 示例一 实现一...
队列和栈
aleo的博客
04-03 256
栈 一张图可以简单的说明 为了达到时间复杂度最低：选择的是python列表实现栈，而列表是顺序表 入栈push的时候选择在列表的尾部进行添加元素，出栈在列表尾部弹出 class Stack(object): """栈""" def __init__(self): self.items = [] def is_empty(self): "...
栈stack和队列
YWX
01-30 1万+
栈和队列一· 栈和队列二· 栈三.队列四.例题 一· 栈和队列 栈和队列是两种重要的线性结构。从数据结构来看，栈和队列也是线性表，其特殊性在于栈和队列的基本操作是线性表操作的子集（也具有顺序结构和链式结构），它们是操作受限的线性表，因此，可称为限定性的数据结构。 二· 栈 定义 ：只能在表的一端（栈顶）进行插入和删除运算的线性表。 逻辑结构：与线性表相同，仍为一对一关系。 存储结构：用顺序栈或链栈存储均可，但以顺序栈更常见。 链栈： 运算规则：只能在栈顶运算，且访问结点时依照后进先出（LIFO）或先进后出
栈和队列、堆、堆栈的区别？
热门推荐
前端的路上
05-26 4万+
队列是先进先出，有出口和入口，先进去可以先出来。栈就像一个箱子，后放上去的，可以先出来堆是在程序运行时，而不是在程序编译时，申请某个大小的内存空间。即动态分配内存，对其访问和对一般内存的访问没有区别。{堆是指程序运行是申请的动态内存，而栈只是指一种使用堆的方法(即先进后出)。栈是先进后出的，但是于堆而言却没有这个特性，两者都是存放临时数据的地方。 对于堆，我们可以随心所欲的进行增加变量和删除变量，...
栈和队列常见的面试题
dreamispossible的博客
09-27 189
（1）实现一个栈，要求实现Push（入栈），Pop（出栈），Min（返回最小值）的时间复杂度为O（1）？
栈与队列面试题解析：从基础到高级应用
"3栈和队列面试题精讲.ppt" 这篇内容主要讲解了与栈和队列相关的面试题目，并提供了详细的解题思路。栈和队列是两种基础且重要的线性数据结构，它们在算法和数据结构领域扮演着至关重要的角色。 线性表是一种简单...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值