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

最新推荐文章于 2022-08-09 12:21:36 发布
最新推荐文章于 2022-08-09 12:21:36 发布
阅读量245 收藏
点赞数
文章标签： 数据结构 栈 队列 面试题
版权声明：本文为博主原创文章，遵循 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
关注
《名企数据结构面试题之--栈与队列（上）》课件和代码
12-25
极客学院，《名企数据结构面试题之--栈与队列（上）》课件和代码。
【数据结构】栈和队列面试题
如风逝去
08-03 371
1、实现一个栈，要求实现Push（出栈）、Pop（入栈）、Min（返回最 小值的操作）的时间复杂度为O(1) 针对这个问题我们可以有两种方法来解决，第一种方法： 我们每次压栈的时候压两个数字，先压数据，然后压最小值，每次压之前和数据比较一下，如果数据比最小值还小就把最小值更新成数据，然后再压数据和最小值，这就是压栈操作。这样可以保证栈顶就是最小值。 接下来是出栈操作，因为我们每次多压了一个...
【数据结构】（面试题）使用两个栈实现一个队列(详细介绍)
weixin_33795833的博客
04-12 671
使用两个栈实现一个队列思路一：我们设定s1是入栈的，s2是出栈的。入队列，直接压到s1即可出队列，先把s1中的元素倒入到s2中，弹出s2中的栈顶元素；再把s2的剩余元素全部倒回s1中。缺点：每次只要出栈一个元素就要将元素倒来倒去，麻烦！！！思路2：入队列时：如果s1为空，把s2中所有的元素倒出压到s1中。否则直接压入s1 出队列时：如果s2不为空，把s2中的栈顶元素直接弹...
【数据结构】栈和队列相关面试题
码农印象
08-17 550
栈和队列面试题（c语言实现） 1.实现一个栈，要求实现Push(入栈)、Pop(出栈)、Min(返回最小值)的时间复杂度为O(1). 2.使用两个栈实现一个队列 3.使用两个队列实现一个栈 4.元素出栈、入栈的合法性。如入栈的序列(1,2,3,4,5),出栈序列为(4,5,3,2,1) 5.一个数组实现两个共享栈 1.实现一个栈，要求实现Push(入栈)...
数据结构之栈和队列面试题（3）两个队列实现一个栈
mignatian的博客
05-06 304
我们知道队列是先进先出，而栈是后进先出的，所以要拿两个队列来实现一个栈，我们思路就应该这样： 每次总保持一个队列为空，对另一个队列进行操作。 入栈操作时，我们在那个有元素的队列后面直接用入队列操作，就相当于是栈的入栈操作。 在进行出栈操作的时候，我们将有元素的队列里面的元素依次出队列，并且入队列另一个队列，当出的还剩一个元素的时候，这个时候出队列的元素就是队尾元素，就相当于栈的出栈。正好就是...
比特数据结构课件-Lesson4-栈和队列.pdf
07-07
本节重点介绍了两种基本的数据结构：栈和队列。 栈是一种遵循后进先出（LIFO）原则的数据结构。在这个结构中，最新的元素（即最后加入的元素）总是最先被移除。栈有两个主要操作：压栈（进栈/入栈），即向栈顶添加...
Java实现栈和队列面试题
09-03
以上就是Java实现栈和队列面试题的主要内容。理解和熟练掌握这些知识点对于Java开发者来说至关重要，因为它们涉及到基础数据结构的运用，能够反映候选人在解决实际问题时的逻辑思维和算法能力。在面试中，候选人可能...
Lesson4--栈和队列.pdf
10-06
下面是一些栈和队列面试题： 1. 括号匹配问题。 2. 用队列实现栈。 3. 用栈实现队列。 4. 设计循环队列。 5. 选择题：循环队列的存储空间为 Q（1:100），初始状态为 front=rear=100 。经过一系列正常的入队与退队...
面试-Java一些常见面试题+题解之数据结构-DataStructure.zip
最新发布
03-03
本资料包"面试-Java一些常见面试题+题解之数据结构-DataStructure.zip"聚焦于Java中的数据结构，旨在帮助求职者更好地准备面试。下面我们将详细探讨其中可能涉及到的一些关键知识点。 1. **数组**： - 数组是最...
数据结构之栈和队列题目汇总
happywq2009的专栏
03-11 891
1.栈的应用： 应用一：括号匹配 http://blog.csdn.net/happywq2009/article/details/44181893 2.两个栈实现队列+两个队列实现栈----C++ http://blog.csdn.net/happywq2009/article/details/44181383 3.设计包含min或max功能的栈 http://blog.cs
数据结构栈和队列试题及答案
11-26
栈和队列考试题 复习 栈和队列考试题 复习栈和队列考试题 复习
数据结构之栈和队列的经典面试题
qq_40955824的博客
08-30 256
1.实现一个栈，要求实现Push(出栈)、Pop(入栈)、Min(返回最小值)的时间复杂度为O(1) 在这个题目中要求要返回一个栈里面的最小值。有两种方法： 1). 用两个栈，一个栈存入栈的数据，另一个栈存对应的最小值，如果入栈的顺序为5，8，1，3，4，则存最小值的那个栈存入的数据应该为5，5，1，1，1。 2). 与上边一样，用两个栈，一个放数据，另一个放最小值，最小值由结构体组成...
数据结构之栈与队列相关面试题
mmwwxx123的博客
07-28 163
实现一个栈，要求返回最小值 有3种方法，分别为： 用一个栈实现，偶数下标存普通数据，奇数下标为最小的值 typedef struct MinStack { int array[100];//偶数下标存普通数据，奇数下标为最小的值 int top; }MinStack; void Init(MinStack *pS) { pS-&gt;top = 0; } /...
数据结构与算法学习②(栈,队列,面试题)
m0_46690280的博客
11-15 505
数组与链表面试题,栈数组与链表面试题数组字节跳动，滴滴打车最近面试题：283. 移动零华为，腾讯最近面试题：11. 盛最多水的容器美团点评，快手最近面试题：88. 合并两个有序数组facebook，谷歌最近面试题：66. 加一字节跳动，美团点评最近面试题：9. 回文数阿里，华为，腾讯最近面试题：1. 两数之和华为，字节跳动最近面试题：18. 四数之和顺丰，小米最近面试题，LCP 18. 早餐组合腾讯，美团点评最近面试题：26. 删除排序数组中的重复项微软，字节跳动最近面试题：189. 旋转数组链表 数组与链
【数据结构】栈与队列的面试题（一）
alidada_blog的博客
05-19 369
栈的简单认识和基本操作：点击打开链接队列的简单认识和基本操作：点击打开链接一.实现一个栈，要求实现Push(出栈)，Pop（出栈），Min(返回最小值)的时间复杂度为O（1）。     （1.）方法一：创建两个栈来实现（Stack1,Stack2）                       思路：                              首先创建栈Stack1和Stack2时把...
数据结构 栈和队列常考面试题--用队列实现栈
weixin_48271092的博客
02-24 163
OJ链接：用队列实现栈 题目描述： 请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。 实现 MyStack 类： void push(int x) 将元素 x 压入栈顶。 int pop() 移除并返回栈顶元素。 int top() 返回栈顶元素。 boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。 注意： · 你只能使用队列的基本操作 —— 也就是push to bac..
【数据结构】队列&栈和队列的面试题
OddSmurfs的博客
09-19 469
栈 栈是一个后进先出（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_44258092的博客
08-09 904
介绍了栈和队列相关的OJ题目。
【数据结构】--几道栈和队列面试题
海绵宝宝的欧尼~ 的博客
05-05 1323
用两个栈实现一个队列 1、思路分析 拿到这道题，会有以下几种思路： 思路一：入队时，将所有的元素压入到s1中 出队时，将s1中的所有元素倒入到s2中，然后让s2中栈顶的元素出栈，然后将s2中所有的元素倒入到s1中问题所在：我们不难发现，在这种解法中，要进行来回倒栈，时间复杂度就会比较大，做起来也比较麻烦 思路二： 说明：是对第一种的优化我们不难发现，其实在进行倒栈的时候，没必要进行最后一个元
"数据结构面试题：栈和队列特点、存储结构、链表优点
"很好的数据结构面试题"文档提供了一系列关于栈、队列和链表的问题，并附有答案。其中，问题1到3涉及栈和队列的特点和存储结构，问题4和5测试对栈的理解，问题6和7探讨链表的特点和优点，问题8和9关注单链表和循环...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值