数据结构-栈和队列相关面试题

最新推荐文章于 2023-01-11 10:18:44 发布
最新推荐文章于 2023-01-11 10:18:44 发布
阅读量226 收藏
点赞数
文章标签： 数据结构 栈 队列 面试题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/y6_xiamo/article/details/79964420
版权

1.实现一个最小栈，每次取得都是栈里面的最小值，时间复杂度为O(1)
思路：每次入栈两个元素，一个存当前值，一个存当前栈的最小值，先将当前值入栈，再将最小值入栈，出栈时也一次出两个。如图所示：
这里写图片描述
代码如下：

#include"seqstack.h"
#include<stdio.h>

typedef struct MinStack
{
    SeqStack stack;
}MinStack;

void MinStackInit(MinStack* min_stack)
{
    if(min_stack == NULL)
    {
        return;
    }
    SeqStackInit(&min_stack->stack);
}

void MinStackPush(MinStack* min_stack,SeqStackType value)
{
    if(min_stack == NULL)
    {
        return;//非法输入
    }
    SeqStackType min = value;
    //取栈顶元素
    SeqStackType top;
    int ret = SeqStackTop(&min_stack->stack,&top);
    if(ret != 0)
    {
        //将栈顶元素和value值进行比较，将小指赋给min
        if(top > value)
        {
            min = value;
        }
        min = top;
    }
    //一次入两个元素，先插value,后插min,才能保证栈顶元素是最小的
    SeqStackPush(&min_stack->stack,value);
    SeqStackPush(&min_stack->stack,min);
}

void MinStackPop(MinStack* min_stack)
{
    if(min_stack == NULL)
    {
        return;//非法输入
    }

    if(min_stack->stack.size == 0)
    {
        return;//空栈
    }
    //连续出栈两个元素
    SeqStackPop(&min_stack->stack);
    SeqStackPop(&min_stack->stack);
    return;
}
int MinStackTop(MinStack* min_stack,SeqStackType* value)
{
    if(min_stack == NULL)
    {
        return 0;//非法输入
    }
    SeqStackTop(&min_stack->stack,value);
}

///////////////////////////////////////
/////////以下是测试代码///////////////
//////////////////////////////////////

#define TEST_HEADER printf("\n==============%s============\n",__FUNCTION__)

void TestMinStack()
{
    TEST_HEADER;
    MinStack min_stack;
    MinStackInit(&min_stack);
    MinStackPush(&min_stack,'a');
    MinStackPush(&min_stack,'b');
    MinStackPush(&min_stack,'c');
    MinStackPush(&min_stack,'d');

    SeqStackType value;
    int ret = MinStackTop(&min_stack,&value);
    printf("ret expected 1,actual %d\n",ret);
    printf("value expected a,actual %c\n",value);

    MinStackPop(&min_stack);
    MinStackPop(&min_stack);
    ret = MinStackTop(&min_stack,&value);
    printf("ret expected 1,actual %d\n",ret);
    printf("value1 expected a,actual %c\n",value);  
}

int main()
{
    TestMinStack();
    printf("\n");
    return 0;
}

2.使用两个栈实现一个队列
思路：一个栈实现入队列的场景，一个栈实现出队列和取队首元素
这里写图片描述
例如上图，按照队列”先进先出”规则，先将a b c d按顺序依次压入input栈，然后取input栈栈顶元素按顺序依次出栈再压入output栈，最后在output栈依次出栈栈顶元素，就达到预期效果。
代码如下：

#include<stdio.h>
#include"seqstack.h"

typedef struct QueueBy2Stack
{
    SeqStack input;
    SeqStack output;
}QueueBy2Stack;

void QueueInit(QueueBy2Stack* queue)
{
    if(queue == NULL)
    {
        return;//非法输入
    }
    SeqStackInit(&queue->input);
    SeqStackInit(&queue->output);
}

void QueuePush(QueueBy2Stack* q,SeqStackType value)
{
    if(q == NULL)
    {
        return;//非法输入
    }
    //先把所有output的元素出栈然后按顺序入栈到input里
    while(1)
    {
        SeqStackType top;
        int ret = SeqStackTop(&q->output,&top);
        if(ret == 0)
        {
            break;
        }
        SeqStackPush(&q->input,top);
        SeqStackPop(&q->output);
    }
    //把新元素value插入到input中
    SeqStackPush(&q->input,value);
    return;
}

void QueuePop(QueueBy2Stack* q)
{
    if(q == NULL)
    {
        return;//非法输入
    }
    //先把input里所有元素倒腾到output里
    while(1)
    {
        SeqStackType top;
        int ret = SeqStackTop(&q->input,&top);
        if(ret == 0)
        {
            break;
        }
        SeqStackPush(&q->output,top);
        SeqStackPop(&q->input);
    }
    SeqStackPop(&q->output);
    return;
}

int QueueFront(QueueBy2Stack* q,SeqStackType* value)
{
    if(q == NULL|| value == NULL)
    {
        return 0;;//非法输入
    }
    //把input里的所有元素倒腾到output里
    while(1)
    {
        SeqStackType top;
        int ret = SeqStackTop(&q->input,&top);
        if(ret == 0)
        {
            break;
        }
        SeqStackPush(&q->output,top);
        SeqStackPop(&q->input);
    }
    return SeqStackTop(&q->output,value);

}
////////////////////////////////////////
//////////以下是测试代码///////////////
///////////////////////////////////////
#if 1
#include<stdio.h>
#define TEST_HEADER printf("\n=================%s================\n",__FUNCTION__)

void TestQueue()
{
    TEST_HEADER;
    QueueBy2Stack queue;
    QueueInit(&queue);
    QueuePush(&queue,'a');
    QueuePush(&queue,'b');
    QueuePush(&queue,'c');
    QueuePush(&queue,'d');

    SeqStackType value;
    int ret = QueueFront(&queue,&value);
    printf("ret expected 1,actual %d\n",ret);
    printf("value expected a,acatual %c\n",value);

    QueuePop(&queue);
    ret = QueueFront(&queue,&value);
    printf("ret expected 1,actual %d\n",ret);
    printf("value expected b,acatual %c\n",value);

    QueuePop(&queue);
    ret = QueueFront(&queue,&value);
    printf("ret expected 1,actual %d\n",ret);
    printf("value expected c,acatual %c\n",value);

    QueuePop(&queue);
    ret = QueueFront(&queue,&value);
    printf("ret expected 1,actual %d\n",ret);
    printf("value expected d,acatual %c\n",value);

    QueuePop(&queue);
    ret = QueueFront(&queue,&value);
    printf("ret expected 0,actual %d\n",ret);
}

int main()
{
    TestQueue();
    printf("\n");
    return 0;
}
#endif

3.使用两个队列实现一个栈
思路：入栈时将元素插入到不为空的队列里，出栈时将不为空的队列里只留下最后一个元素，将其余元素出队列然后插入到另一个空队列里。需要注意的是要搞清楚将元素从哪个队列倒腾到哪个队列。
这里写图片描述
代码如下：

#include<stdio.h>
 #include"seqqueue.h"

typedef struct StackBy2Queue
{
    SeqQueue queue1;
    SeqQueue queue2;
}StackBy2Queue;

void StackInit(StackBy2Queue* stack)
{
    if(stack == NULL)
    {
        return;//非法输入
    }

    SeqQueueInit(&stack->queue1);
    SeqQueueInit(&stack->queue2);
}

void StackPush(StackBy2Queue* stack,SeqQueueType value)
{
    if(stack == NULL)
    {
        return;//非法输入
    }
    SeqQueue* input;
    //先判断哪个队列不为空，然后将元素插入到那个队列里
    if(stack->queue1.size != 0)
    {
        input = &stack->queue1;
    }
    input = &stack->queue2;
    SeqQueuePush(input,value);
}

void StackPop(StackBy2Queue* stack)
{
    if(stack == NULL)
    {
        return;//非法输入
    }
    //如果是空栈，直接返回
    if(stack->queue1.size == 0 && stack->queue2.size == 0)
    {
        return;
    }
    //先判断哪个队列为空,不为空队列为from,空队列为to
    SeqQueue* from = NULL;
    SeqQueue* to = NULL;
    if(stack->queue1.size > 0)
    {
        from = &stack->queue1;
        to = &stack->queue2;
    }
    else
    {
        from = &stack->queue2;
        to = &stack->queue1;
    }
    //把from中的元素倒腾到to中，直到from中只剩下一个元素
    while(1)
    {
        if(from->size == 1)
        {
            break;
        }
        SeqQueueType value;
        int ret = SeqQueueFront(from,&value);
        SeqQueuePop(from);
        SeqQueuePush(to,value);
    }
    SeqQueuePop(from);
}

int StackFront(StackBy2Queue* stack,SeqQueueType* value)
{
    if(stack == NULL)
    {
        return 0;//非法输入
    }
    //如果是空栈，直接返回
    if(stack->queue1.size == 0 && stack->queue2.size == 0)
    {
        return 0;
    }
    //先判断哪个队列为空,不为空队列为from,空队列为to
    SeqQueue* from = NULL;
    SeqQueue* to = NULL;
    if(stack->queue1.size > 0)
    {
        from = &stack->queue1;
        to = &stack->queue2;
    }
    else
    {
        from = &stack->queue2;
        to = &stack->queue1;
    }
    //把from中的元素倒腾到to中，直到from中只剩下一个元素
    while(1)
    {
        if(from->size == 1)
        {
            break;
        }
        SeqQueueFront(from,value);
        SeqQueuePop(from);
        SeqQueuePush(to,*value);
    }
    //将剩下的最后一个元素取出来赋给value
    SeqQueueFront(from,value);
    SeqQueuePop(from);
    SeqQueuePush(to,*value);
    return 1;
}

//以下是测试代码///
//
#if 1
#include<stdio.h>
#define TEST_HEADER printf("\n====================%s=======================\n",__FUNCTION__)
void TestStack()
{
    TEST_HEADER;
    StackBy2Queue stack;
    StackInit(&stack);
    StackPush(&stack,'a');
    StackPush(&stack,'b');
    StackPush(&stack,'c');
    StackPush(&stack,'d');

    SeqQueueType value;
    int ret = StackFront(&stack,&value);
    printf("ret expected 1,actual %d\n",ret);
    printf("value expected d,actual %c\n",value);

    StackPop(&stack);
    ret = StackFront(&stack,&value);
    printf("ret expected 1,actual %d\n",ret);
    printf("value expected c,actual %c\n",value);

    StackPop(&stack);
    ret = StackFront(&stack,&value);
    printf("ret expected 1,actual %d\n",ret);
    printf("value expected b,actual %c\n",value);

    StackPop(&stack);
    ret = StackFront(&stack,&value);
    printf("ret expected 1,actual %d\n",ret);
    printf("value expected a,actual %c\n",value);

    StackPop(&stack);
    ret = StackFront(&stack,&value);
    printf("ret expected 0,actual %d\n",ret);
}
int main()
{
    TestStack();
    printf("\n");
    return 0;
}
#endif

4.判断一个入栈序列是否可以通过入栈、出栈操作得到出栈序列，如，入栈序列(input)为（a,b,c,d,e),出栈序列(output)为(d,e,c,b,a)
思路：定义两重循环，第一重，循环的遍历input,然后将input中的元素入栈；第二重，取栈顶元素，如果栈顶元素的值和oi指向的值相同，循环的出栈，并且再次比较栈顶元素和oi移进之后的值。
这里写图片描述
代码如下：

#include<stdio.h>
#include<stddef.h>
#include"seqstack.h"
#include<string.h>

//返回1表示能变换成功
//返回0表示不能变换成功
int StackOrder(char input[],size_t input_size,char output[],size_t output_size)
{
    SeqStack stack;
    SeqStackInit(&stack);
    size_t i = 0;
    size_t output_index = 0;
    char top;
    for( ;i < input_size;i++)
    {

      //1.循环的把input入栈
          SeqStackPush(&stack,input[i]);
          int ret = SeqStackTop(&stack,&top);
         //2.取栈顶元素，和output_index指向的元素进行比较
          while(1)
          {
                SeqStackTop(&stack,&top);
                 if(output_index >= output_size)
                 {
                     break;//output_index走到output数组的最后一个
                 }
                 //3.如果不相等，继续循环取下一个input元素入栈
                 if(top != output[output_index])
                 {
                     break;
                 }
                 //4.如果相等
                //  a)移进output_index
                //  b)把栈顶元素出栈
                //  c)再循环的比较栈顶元素和output_index指向的值
                 ++output_index;
                 SeqStackPop(&stack);
          }
          if(ret == 0)
          {
              break;//栈为空进行最终审判
          }
    }

    //5.如果最后栈为空并且output_index指向output数组中的最后一个元素的下一个元素，
    //就认为output可以通过input变换得到
    //6.否则则不能通过变换得到
    if(stack.size == 0 && output_index == output_size)
    {
        return 1;
    }
    return 0;
}
////////////////////////////////////
//////////以下为测试代码////////////
///////////////////////////////////
#if 1
#include<stdio.h>
#define TEST_HEADER printf("\n====================%s======================\n",__FUNCTION__)
void TestOrder()
{
    TEST_HEADER;
    char input[6] = "abcde";
    char output[6] = "decba";
    size_t input_size = strlen(input);
    size_t output_size = strlen(output);
    int ret = StackOrder(input,input_size,output,output_size);
    printf("ret expected 1,actual %d\n",ret);
    if(ret == 1)
    {
        printf("output 可以通过input变换得到\n");
    }
    else
    {
        printf("output 不能通过input变换得到\n");
    }   
}
int main()
{
    TestOrder();
    printf("\n");
    return 0;
}
#endif

5.一个数组实现两个栈（共享栈）
这里写图片描述
我们做一种约定：第一个栈区间为[0,top1），第二个栈区间为[top2,max_size),当top1 == top2表示栈满了。
代码如下：

#include<stdio.h>
#include<stddef.h>
#define SharedStackMixSize 1000

typedef char SharedStackType;

//[0,top1)表示第一个栈
//[top2,SharedSatckMixSize)表示第二个栈
typedef struct SharedStack
{
    SharedStackType data[SharedStackMixSize];
    size_t top1;
    size_t top2;
}SharedStack;

void SharedStackInit(SharedStack* stack)
{
    if(stack == NULL)
    {
        return;//非法输入
    }
    stack->top1 = 0;
    stack->top2 = SharedStackMixSize;
    return;
}

void SharedStackPush1(SharedStack* stack,SharedStackType value)
{
    if(stack == NULL)
    {
        return;//非法输入
    }
    if(stack->top1 >= stack->top2)
    {
        return;//栈已满，不能再插入元素
    }
    stack->data[stack->top1++] = value;//将元素插入到top1指向的位置，再将top1指向下一个位置
    return;
}

void SharedStackPush2(SharedStack* stack,SharedStackType value)
{
    if(stack == NULL)
    {
        return;//非法输入
    }
    if(stack->top1 >= stack->top2)
    {
        return;//栈已满，不能再插入元素
    }
    stack->data[--stack->top2] = value;//先将top2减一，再将元素插入到top2指向的位置
    return;
}

int SharedStackTop1(SharedStack* stack,SharedStackType* value)
{
    if(stack == NULL)
    {
        return 0;//非法输入
    }
    if(stack->top1 == 0)
    {
        return 0;//空栈
    }
    *value = stack->data[stack->top1-1];//top1的前一个位置为有效值，将其赋给value
    return 1;
}

int SharedStackTop2(SharedStack* stack,SharedStackType* value)
{
    if(stack == NULL)
    {
        return 0;//非法输入
    }
    if(stack->top2 == SharedStackMixSize)
    {
        return 0;//空栈
    }
    *value = stack->data[stack->top2];//top2指向的位置就是有效值，将其赋给value
    return 1;
}

void SharedStackPop1(SharedStack* stack)
{
    if(stack == NULL)
    {
        return;//非法输入
    }
    if(stack->top1 == 0)
    {
        return;//空栈
    }
    --stack->top1;
    return;
}

void SharedStackPop2(SharedStack* stack)
{
    if(stack == NULL)
    {
        return;//非法输入
    }
    if(stack->top2 == SharedStackMixSize)
    {
        return;//空栈
    }
    ++stack->top2;
    return;
}
/
///以下是测试代码///
///
#include<stdio.h>
#if 1
#define TEST_HEADER printf("\n=======================%s====================\n",__FUNCTION__)
void TestInit()
{
    TEST_HEADER;
    SharedStack stack;
    SharedStackInit(&stack);
}
void Test1()
{

    TEST_HEADER;
    SharedStack stack;
    SharedStackInit(&stack);
    SharedStackPush1(&stack,'a');
    SharedStackPush1(&stack,'b');
    SharedStackPush1(&stack,'c');
    SharedStackPush1(&stack,'d');

    SharedStackType value;
    int ret = SharedStackTop1(&stack,&value);
    printf("ret expected 1,actual %d\n",ret);
    printf("value expected d,actual %c\n",value);

    SharedStackPop1(&stack);
    SharedStackPop1(&stack);
    ret = SharedStackTop1(&stack,&value);
    printf("ret expected 1,actual %d\n",ret);
    printf("value expected b,actual %c\n",value);

    SharedStackPop1(&stack);
    SharedStackPop1(&stack);
    ret = SharedStackTop1(&stack,&value);
    printf("ret expected 0,actual %d\n",ret);
}

void Test2()
{

    TEST_HEADER;
    SharedStack stack;
    SharedStackInit(&stack);
    SharedStackPush2(&stack,'a');
    SharedStackPush2(&stack,'b');
    SharedStackPush2(&stack,'c');
    SharedStackPush2(&stack,'d');

    SharedStackType value;
    int ret = SharedStackTop2(&stack,&value);
    printf("ret expected 1,actual %d\n",ret);
    printf("value expected d,actual %c\n",value);

    SharedStackPop2(&stack);
    SharedStackPop2(&stack);
    ret = SharedStackTop2(&stack,&value);
    printf("ret expected 1,actual %d\n",ret);
    printf("value expected b,actual %c\n",value);

    SharedStackPop2(&stack);
    SharedStackPop2(&stack);
    ret = SharedStackTop2(&stack,&value);   
    printf("ret expected 0,actual %d\n",ret);
}
int main()
{
    TestInit();
    Test1();
    Test2();
    printf("\n");
    return 0;
}
#endif
y6_xiamo
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构—栈和队列经典面试题
3166375975@的博客
09-21 8687
栈和队列面试题： 实现一个栈，要求实现Push(出栈)、Pop(入栈)、Min(返回最小值)的时间复杂度为O(1) 使用两个栈实现一个队列 使用两个队列实现一个栈 元素出栈、入栈顺序的合法性。如入栈的序列(1,2,3,4,5)，出栈序列为 (4,5,3,2,1) 一个数组实现两个栈(共享栈) 实现一个栈，要求实现Push(出栈)、Pop(入栈)、Min(返回最小值)的时间复杂度为O...
数据结构之堆栈9一些补充
OVS98
09-29 707
1．栈 1.1 栈的定义 栈是一种特殊的线性表。其特殊性在于限定插入和删除数据元素的操作只能在线性表的一端进行。如下所示： 结论：后进先出（Last In First Out），简称为LIFO线性表。 栈的基本运算有六种： 构造空栈：InitStack(S)、 判栈空: StackEmpty(S)、 判栈满： StackFull(S)、 进栈： Push(S,x)、
栈与栈的经典面试题
VIBE的博客
09-25 1246
一次保存单个同类型元素，多个元素之间逻辑上连续例如：数组，链表，栈，队列，字符串（内部就是char[]）上述讲的数组也罢，链表也罢，既可以在头部插入和删除，也能在尾部插入和删除，甚至可以在任意位置都可以插入和删除。"栈和队列"只能在一端插入元素和删除元素。
【数据结构之栈系列】栈及其经典面试题详解
胡坚涛的博客
01-11 963
前面学习的线性表中包含顺序表和链表，这两种数据结构允许在任意位置进行插入和删除，那么有没有一种数据结构是不能在任意位置进行插入删除，而只允许在一边进行插入删除的呢？？当然有的，这就是我们今天要学习的一种新的数据结构：栈
【数据结构】栈和队列面试题总结(持续更新中...)
weixin_44258092的博客
08-09 634
介绍了栈和队列相关的OJ题目。
比特数据结构课件-Lesson4-栈和队列.pdf
07-07
本节重点介绍了两种基本的数据结构：栈和队列。 栈是一种遵循后进先出（LIFO）原则的数据结构。在这个结构中，最新的元素（即最后加入的元素）总是最先被移除。栈有两个主要操作：压栈（进栈/入栈），即向栈顶添加...
Java实现栈和队列面试题
09-03
以上就是Java实现栈和队列面试题的主要内容。理解和熟练掌握这些知识点对于Java开发者来说至关重要，因为它们涉及到基础数据结构的运用，能够反映候选人在解决实际问题时的逻辑思维和算法能力。在面试中，候选人可能...
算法大全-面试题-链表-栈-二叉树-数据结构.docx
09-01
算法大全-面试题-链表-栈-二叉树-数据结构，C#版，主要三大块，一，单链表，二，栈和队列，三，二叉树。 每一大块又有许多新鲜好玩的玩法，你会很喜欢的会上瘾的。 适合玩算法的朋友。
Lesson4--栈和队列.pdf
10-06
下面是一些栈和队列面试题： 1. 括号匹配问题。 2. 用队列实现栈。 3. 用栈实现队列。 4. 设计循环队列。 5. 选择题：循环队列的存储空间为 Q（1:100），初始状态为 front=rear=100 。经过一系列正常的入队与退队...
《名企数据结构面试题之--栈与队列（上）》课件和代码
12-25
极客学院，《名企数据结构面试题之--栈与队列（上）》课件和代码。
数据结构栈和队列试题及答案
11-26
栈和队列考试题 复习 栈和队列考试题 复习栈和队列考试题 复习
【数据结构】栈和队列面试题
如风逝去
08-03 350
1、实现一个栈，要求实现Push（出栈）、Pop（入栈）、Min（返回最 小值的操作）的时间复杂度为O(1) 针对这个问题我们可以有两种方法来解决，第一种方法： 我们每次压栈的时候压两个数字，先压数据，然后压最小值，每次压之前和数据比较一下，如果数据比最小值还小就把最小值更新成数据，然后再压数据和最小值，这就是压栈操作。这样可以保证栈顶就是最小值。 接下来是出栈操作，因为我们每次多压了一个...
【数据结构】队列&栈和队列的面试题
OddSmurfs的博客
09-19 433
栈 栈是一个后进先出（LILO）的特殊线性表，以下采用静态顺序表的方式，简单的模拟一个栈 存储方式 #define MAX_SIZE 100 typedef int DataType; typedef struct { DataType arr[MAX_SIZE]; int top; }Stack; 相关操作 //初始化 void StackInit(Stack *ps) { ps-&amp;amp;amp;amp;g...
【数据结构】（面试题）使用两个栈实现一个队列(详细介绍)
weixin_33795833的博客
04-12 633
使用两个栈实现一个队列思路一：我们设定s1是入栈的，s2是出栈的。入队列，直接压到s1即可出队列，先把s1中的元素倒入到s2中，弹出s2中的栈顶元素；再把s2的剩余元素全部倒回s1中。缺点：每次只要出栈一个元素就要将元素倒来倒去，麻烦！！！思路2：入队列时：如果s1为空，把s2中所有的元素倒出压到s1中。否则直接压入s1 出队列时：如果s2不为空，把s2中的栈顶元素直接弹...
数据结构算法常见面试考题
热门推荐
Zuoerfeng
11-08 13万+
（1） 红黑树的了解（平衡树，二叉搜索树），使用场景 把数据结构上几种树集中的讨论一下： 1.AVLtree 定义：最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为高度平衡树。查找、插入和删除在平均和最坏情况下都是O（log n）。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。 节点的平衡因子是它的左子树的高度减去它的右子树的高度（有时相反）。...
【面试题】栈和队列的面试题
皓皓松的博客
02-20 2344
题目一：实现一个栈，要求其入栈，出栈，返回最小值的时间复杂度为O(1) 这道题目，主要问题在于如何时查找最小元素的时间复杂度为O(1)，这里我们先想到了用一个变量存取最小值 在仅仅入栈时，我们可以通过该MinElem这个变量来查找最小值是完全没有问题的； 但是，如果我们进行出栈，并且把该最小值出栈后，那最小值是不是就找不到了； 下面是正确的解法： 这里我们要用两个栈，第一
数据结构之栈和队列的经典面试题
qq_40955824的博客
08-30 232
1.实现一个栈，要求实现Push(出栈)、Pop(入栈)、Min(返回最小值)的时间复杂度为O(1) 在这个题目中要求要返回一个栈里面的最小值。有两种方法： 1). 用两个栈，一个栈存入栈的数据，另一个栈存对应的最小值，如果入栈的顺序为5，8，1，3，4，则存最小值的那个栈存入的数据应该为5，5，1，1，1。 2). 与上边一样，用两个栈，一个放数据，另一个放最小值，最小值由结构体组成...
数据结构与算法学习②(栈,队列,面试题)
m0_46690280的博客
11-15 469
数组与链表面试题,栈数组与链表面试题数组字节跳动，滴滴打车最近面试题：283. 移动零华为，腾讯最近面试题：11. 盛最多水的容器美团点评，快手最近面试题：88. 合并两个有序数组facebook，谷歌最近面试题：66. 加一字节跳动，美团点评最近面试题：9. 回文数阿里，华为，腾讯最近面试题：1. 两数之和华为，字节跳动最近面试题：18. 四数之和顺丰，小米最近面试题，LCP 18. 早餐组合腾讯，美团点评最近面试题：26. 删除排序数组中的重复项微软，字节跳动最近面试题：189. 旋转数组链表 数组与链
数据结构笔试题---栈
王明海的专栏
10-28 2886
1、设栈S和队列Q的初始状态为空，元素e1、e2、e3、e4、e5、e6一次压入栈S，一个元素出栈后即进入队列Q，若出队列的顺序为e2、e4、e3、e6、e5、e1，则栈S的容量要求最小值为（） A、2      B、3 C、4 D、5 解析：
c++ 数据结构面试题
最新发布
09-03
3、栈和队列：栈是一种先进后出（LIFO）的数据结构，常用于表达式求值和函数调用等场景。队列是一种先进先出（FIFO）的数据结构，常用于多线程同步和任务调度等场景。相关问题包括栈和队列的实现以及应用。 4、树和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值