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

最新推荐文章于 2022-08-09 12:21:36 发布
最新推荐文章于 2022-08-09 12:21:36 发布
阅读量277 收藏
点赞数 1
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mxrrr_sunshine/article/details/79913771
版权

实现一个栈，要求实现push，pop，min的时间复杂度最低。
思路是:入栈时一次入两个元素，第一个元素是要入栈的元素，第二个元素是min，min为当前栈的最小元素与插入元素的较小的那个元素。出栈时每次出两个，保证栈的结构仍然是先进后出。取栈顶元素时，也能保证每次取到的都是栈里最小的元素。

//实现一个栈要求，出栈入栈，返回最小值的时间复杂度是O(1)
typedef struct min_stack
{
    SeqStack stack; 
}min_stack;
void MinStackPush(min_stack* s,StackType value)
{
    if(s==NULL)
    {
        return;
    }
    StackType n;
    StackType min=value;
    int ret=SeqStackTop(&s->stack,&n);
    if(ret==0)
    {
        SeqStackPush(&s->stack,value);
        SeqStackPush(&s->stack,min);
        return;
    }
    if(value>n)
    {
        min=n;    
    }
    SeqStackPush(&s->stack,value);
    SeqStackPush(&s->stack,min);
}
void MinStackPop(min_stack* s)
{
    if(s==NULL)
    {
        return;
    }
    if(s->stack.size==0)
    {
        return;
    }
    SeqStackPop(&s->stack);
    SeqStackPop(&s->stack);
}
int MinStackTop(min_stack* s,StackType* value)
{
    if(s==NULL)
    {
        return 0;
    }
    if(s->stack.size==0)
    {
        return 0;
    }
    SeqStackTop(&s->stack,value);
    return 1;
}

测试代码：

void TestMin()
{
    min_stack s;
    StackType value;
    SeqStackInit(&s.stack);
    MinStackPush(&s,'d');
    int ret=MinStackTop(&s,&value);
    printf("ret expect 1,actual %d\n",ret);
    printf("top expect d,actual %c\n",value);
    MinStackPush(&s,'c');
    MinStackPush(&s,'b');
    MinStackPush(&s,'a');
    ret=MinStackTop(&s,&value);
    printf("ret expect 1,actual %d\n",ret);
    printf("top expect a,actual %c\n",value);
    MinStackPop(&s);
    ret=MinStackTop(&s,&value);
    printf("ret expect 1,actual %d\n",ret);
    printf("top expect b,actual %c\n",value);

}

这里写图片描述

使用两个栈实现一个队列
思路：定义两个栈，一个栈做输入用，一个栈做输出用，入栈时在输入这个栈里入栈，出栈与取栈顶元素都从输出这个栈里取。
这里写图片描述

//使用两个栈实现一个队列

typedef struct Queby2stack
{
    SeqStack input;
    SeqStack output;

}Queby2stack;

void Queueby2stackPush(Queby2stack* q,StackType value)
{
    if(q==NULL)
    {
        return;//非法输入
    }
    StackType top;
    while(q->output.size!=0)
    {
        SeqStackTop(&q->output,&top);
        SeqStackPop(&q->output);
        SeqStackPush(&q->input,top);
    }
    SeqStackPush(&q->input,value);
    while(q->input.size!=0)
    {
        SeqStackTop(&q->input,&top);
        SeqStackPop(&q->input);
        SeqStackPush(&q->output,top);
    }
}
void Queby2stackPop(Queby2stack* q)
{
    if(q==NULL)
    {
        return;
    }
    if(q->output.size==0)
    {
        return;
    }
    SeqStackPop(&q->output);
}

int Queby2stackTop(Queby2stack* q,StackType* value)
{
    if(q==NULL)
    {
        return 0;
    }
    if(q->output.size==0)
    {
        return 0;
    }
    SeqStackTop(&q->output,value);
    return 1;
}


void TestQueby2stack()
{
    Queby2stack q;
    StackType value;
    SeqStackInit(&q.input);
    SeqStackInit(&q.output);
    Queueby2stackPush(&q,'a');
    Queueby2stackPush(&q,'b');
    Queueby2stackPush(&q,'c');
    Queueby2stackPush(&q,'d');
    Queby2stackPrint(&q,"入队列");
    Queby2stackTop(&q,&value);
    printf("top expect a,actual %c\n",value);
    Queby2stackPop(&q);
    Queby2stackPop(&q);
    Queby2stackPrint(&q,"出队列");
    Queby2stackTop(&q,&value);
    printf("top expect c,actual %c\n",value);

}

这里写图片描述

使用两个队列实现一个栈
思路：这个题目相比于两个栈实现一个队列要复杂一些，两个栈都有既定的目标，一个做输入一个作输出。但是这两个队列没有特殊的区别。两个队列都做输出，也都做输入。画一张图来说明。
首先两个空队列，并且将元素入队列至其中一个队列中，因为我们是要实现一个栈，所以先进后出，所以出栈时应该要先出e，但是由于队列的结构限制，我们现在出队列只能出a，所以这时借助第二个队列来做一个“桥梁”。
这里写图片描述
将队列1中前几个元素都入队列至第二个队列中，此时队列1中只有e一个元素，此时再将它出队列，就能达到出栈的效果。

这里写图片描述

大致的过程就是这样，这种结构在做出栈入栈取栈顶元素时，要做的最重要的一件事是判断在该时刻哪一个队列是非空的，就对哪一个队列做入栈操作，出栈操作则要借助第二个队列。

//用两个队列实现一个栈
typedef struct Stackby2que
{
    SeqQueue que1;
    SeqQueue que2;
}Stackby2que;
void Stackby2quePush(Stackby2que* s,SeqQueType value)
{
    if(s==NULL)
    {
        return;
    }
    if(s->que1.size!=0)
    {
        SeqQueuePush(&s->que1,value);
    }
    else
    {
        SeqQueuePush(&s->que2,value);
    }
}
void Stackby2quePop(Stackby2que* s)
{
    if(s==NULL)
    {
        return;
    }
    if(s->que1.size==0&&s->que2.size==0)
    {
        return;
    }
    if(s->que1.size!=0)
    {
        SeqQueType top;
        while(s->que1.size!=1)
        {
            SeqQueueTop(&s->que1,&top);
            SeqQueuePop(&s->que1);
            SeqQueuePush(&s->que2,top);
        }
        SeqQueuePop(&s->que1);
    }
    else if(s->que2.size!=0)
    {
        SeqQueType top;
        while(s->que2.size!=1)
        {
            SeqQueueTop(&s->que2,&top);
            SeqQueuePop(&s->que2);
            SeqQueuePush(&s->que1,top);
        }
        SeqQueuePop(&s->que2);
    }
}
int Stackby2queTop(Stackby2que* s,SeqQueType* value)
{
    if(s==NULL||value==NULL)
    {
        return 0;
    }
    if(s->que1.size==0&&s->que2.size==0)
    {
        return 0;
    }
    if(s->que1.size!=0)
    {
        while(1)
        {
            SeqQueueTop(&s->que1,value);
            SeqQueuePush(&s->que2,*value);
            SeqQueuePop(&s->que1);
            if(s->que1.size==0)
            {
                return 1;
            }
        }
    }
    else if(s->que2.size!=0)
    {
        while(1)
        {
            SeqQueueTop(&s->que2,value);
            SeqQueuePush(&s->que1,*value);
            SeqQueuePop(&s->que2);
            if(s->que2.size==0)
            {
                return 1;
            }
        }
    }
    return 0;
}
/////////////////////////////////////////////
//测试
////////////////////////////////////////////
void Stackby2quePrint(Stackby2que* s,const char* msg)
{
    printf("%s\n",msg);
    if(s->que1.size!=0)
    {
        size_t i=s->que1.head;
        for(;i!=s->que1.tail;i++)
        {
            if(i>=MaxSize)
            {
                i=0;
            }
            printf("[%c] ",s->que1.data[i]);
        }
        printf("\n");
    }
    else if(s->que2.size!=0)
    {
        size_t i=s->que2.head;
        for(;i!=s->que2.tail;i++)
        {
            if(i>=MaxSize)
            {
                i=0;
            }
            printf("[%c] ",s->que2.data[i]);
        }
        printf("\n");
    }
}

void TestStackby2que()
{
    Stackby2que s;
    SeqQueType value;
    SeqQueueInit(&s.que1);
    SeqQueueInit(&s.que2);
    Stackby2quePush(&s,'a');
    Stackby2quePush(&s,'b');
    Stackby2quePush(&s,'c');
    Stackby2quePush(&s,'d');
    Stackby2quePrint(&s,"入栈");
    Stackby2queTop(&s,&value);
    printf("top expect d,actual %c\n",value);
    Stackby2quePop(&s);
    Stackby2quePrint(&s,"出栈");
    Stackby2quePop(&s);
    Stackby2quePrint(&s,"出栈");
    Stackby2queTop(&s,&value);
    printf("top expect b,actual %c\n",value);

}

这里写图片描述
元素出栈入栈的合法性
这道题的意思是指，如果入栈的序列（1，2，3，4，5），出栈序列为（4，5，3，2，1）是否合法。
首先有两个序列，先将入栈序列从第一个开始入栈，入栈一个之后取栈顶元素，与第二个序列开始比较，如果不相等，就继续入栈，如果想等，就将该元素出栈，在取当前栈顶元素与该序列的下一个元素比较，以此类推，直到第二个序列全部都比较完毕了，说明此时成立。如果第一个序列全部入完，但是此时第二个序列还没有比较完，那么就不成立。
这里写图片描述


int StackCorrect(SeqStack* stack,char* str1,char *str2,int len)
{
    if(stack==NULL||str1==NULL||str2==NULL)
    {
        return 0;
    }
    int i=0;
    for(;i<len;i++)
    {
        //入栈一个元素，取栈顶元素与比较序列的元素比较
        StackType top;
        SeqStackPush(stack,*str1);
        SeqStackTop(stack,&top);
        while(top==*str2)
        {
            //如果栈顶元素与比较序列相等，就出栈，然后比较下一个
            SeqStackPop(stack);
            SeqStackTop(stack,&top);
            str2++;
        }
        str1++;
    }
    if(*str2=='\0')
    {
        return 1;
    }
    return 0;
}

void TestStackCorrect()
{
    SeqStack stack;
    SeqStackInit(&stack);
    char str1[]="abcde";
    char str2[]="bcdea";
    char str3[]="ceabd";
    int len=strlen(str1);

    int ret=StackCorrect(&stack,str1,str2,len);
    printf("ret expect 1,actual %d\n",ret);
    ret=StackCorrect(&stack,str1,str3,len);
    printf("ret expect 0,actual %d\n",ret);

}

这里写图片描述

用一个数组实现两个栈
我们可以用一个数组的两端模拟两个栈顶。一个栈顶元素是top1，一个栈顶元素是top2。这样就实现了一个数组中同时存在两个栈。如下图所示。
一个栈的区间是：[0,top1)
一个栈的区间是：(top2,MAX_SIZE]
这里写图片描述

//用一个数组实现两个栈
//[0,top1)
//(top2,MAX_SIZE]
#define MAX_SIZE 100
typedef char ShareStackType;
typedef struct ShareStack
{
    ShareStackType data[MAX_SIZE];
    size_t top1;
    size_t top2;

}ShareStack;
void ShareStackInit(ShareStack* stack)
{
    if(stack==NULL)
    {
        return;
    }
    stack->top1=0;
    stack->top2=MAX_SIZE;
}
void ShareStackPush1(ShareStack* stack,ShareStackType value)
{
    if(stack==NULL)
    {
        return;
    }
    if(stack->top1==stack->top2)
    {
        return;
    }
    stack->data[stack->top1++]=value;
}
void ShareStackPush2(ShareStack* stack,ShareStackType value)
{
    if(stack==NULL)
    {
        return;
    }
    if(stack->top1==stack->top2)
    {
        return;
    }
    stack->data[stack->top2--]=value;
}
void ShareStackpPop1(ShareStack* stack)
{
    if(stack==NULL)
    {
        return;
    }
    stack->top1--;
}
void ShareStackpPop2(ShareStack* stack)
{
    if(stack==NULL)
    {
        return;
    }
    stack->top2++;
}
int ShareStackTop1(ShareStack* stack,ShareStackType* value)
{
    if(stack==NULL)
    {
        return 0;
    }
    if(stack->top1==stack->top2)
    {
        return 0;
    }
    *value=stack->data[stack->top1-1];
    return 1;

}

int ShareStackTop2(ShareStack* stack,ShareStackType* value)
{
    if(stack==NULL)
    {
        return 0;
    }
    if(stack->top1==stack->top2)
    {
        return 0;
    }
    *value=stack->data[stack->top2+1];
    return 1;

}

这里写图片描述

mxrrr_sunshine
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
栈和队列面试题（C语言版）
BOXING666的博客
08-14 1144
1.判断出入栈的合法性 https://blog.csdn.net/Payshent/article/details/69951411 2.使用两个栈实现一个队列 思想：1.栈1中的所有数据弹到栈2中（栈2为空栈）            2.再从栈2弹出所有数据，则可出现队列的效果 （默认压数据压到队列1中，从队列2出数据） typedef struct Stack { DataT...
栈和队列经典面试题
bit_zyx的博客
04-07 3082
目录 1、括号匹配问题 2、用队列实现栈 3、用栈实现队列 4、设计循环队列 1、括号匹配问题 链接直达： 有效的括号 题目： 思路： 2、用队列实现栈 3、用栈实现队列 4、设计循环队列 ...
栈和队列面试题
xuruhua的博客
12-18 422
栈和队列面试题 1、实现一个栈，要求实现push（入栈），pop（出栈），Min（返回最小值）的时间复杂度为O（1） 方式1：给定两个栈，一个栈保存数据，一个栈保存最小值。取一个数据，压入数据栈中，同时向最小值栈中存入一个数据。取下一个数据，若是下一个数据小于最小值栈中的栈顶数据，则将该数据插入数据栈同时压入最小值栈中；否则压入数据栈中。 class Solution { public: ...
【数据结构】栈和队列面试题总结(持续更新中...)
weixin_44258092的博客
08-09 646
介绍了栈和队列相关的OJ题目。
Java实现栈和队列面试题
09-03
以上就是Java实现栈和队列面试题的主要内容。理解和熟练掌握这些知识点对于Java开发者来说至关重要，因为它们涉及到基础数据结构的运用，能够反映候选人在解决实际问题时的逻辑思维和算法能力。在面试中，候选人可能...
比特数据结构课件-Lesson4-栈和队列.pdf
07-07
本节重点介绍了两种基本的数据结构：栈和队列。 栈是一种遵循后进先出（LIFO）原则的数据结构。在这个结构中，最新的元素（即最后加入的元素）总是最先被移除。栈有两个主要操作：压栈（进栈/入栈），即向栈顶添加...
面试-Java一些常见面试题+题解之数据结构-DataStructure.zip
最新发布
03-03
本资料包"面试-Java一些常见面试题+题解之数据结构-DataStructure.zip"聚焦于Java中的数据结构，旨在帮助求职者更好地准备面试。下面我们将详细探讨其中可能涉及到的一些关键知识点。 1. **数组**： - 数组是最...
Lesson4--栈和队列.pdf
10-06
下面是一些栈和队列面试题： 1. 括号匹配问题。 2. 用队列实现栈。 3. 用栈实现队列。 4. 设计循环队列。 5. 选择题：循环队列的存储空间为 Q（1:100），初始状态为 front=rear=100 。经过一系列正常的入队与退队...
算法大全-面试题-链表-栈-二叉树-数据结构.docx
09-01
算法大全-面试题-链表-栈-二叉树-数据结构，C#版，主要三大块，一，单链表，二，栈和队列，三，二叉树。 每一大块又有许多新鲜好玩的玩法，你会很喜欢的会上瘾的。 适合玩算法的朋友。
数据结构之堆栈9一些补充
OVS98
09-29 712
1．栈 1.1 栈的定义 栈是一种特殊的线性表。其特殊性在于限定插入和删除数据元素的操作只能在线性表的一端进行。如下所示： 结论：后进先出（Last In First Out），简称为LIFO线性表。 栈的基本运算有六种： 构造空栈：InitStack(S)、 判栈空: StackEmpty(S)、 判栈满： StackFull(S)、 进栈： Push(S,x)、
常见栈、队列面试题
tanglinghui的专栏
06-06 5451
这篇文章里的题目均整理于Cracking the Code Interview 2nd Edition。栈和队列一般不会在面试题里面单独做为一整个题出现，往往都是作为一种辅助的数据结构，利用栈和队列的性质去解决某一类题目。 栈Stack的特点，先进后出，LIFO。栈的基本操作：push压栈，pop出栈，peek返回栈顶元素但栈不变化。 栈和队列里的元素实现 in Java，这里用到的范
关于队列和栈的几道面试题
宇哲
09-18 2495
关于队列和栈的几道面试题今天来说几道简单的栈和队列相关的几道面试题：1 . 实现一个栈，要求实现Push（出栈）、Pop（入栈）、Min（返回最小值的操作）的时间复杂度为O (1 )第一道题，我们需要分析，我想一般的思维肯定是想到，开辟一块空间，进行保存最小值，这种方法也是大家通常地一下就可以想到的。但是在这里会有一个问题，就是如果你的最小值在栈顶，当你pop了栈顶以后，下面的数据中最小的元素就
栈与队列面试题一
可乐不解渴
04-23 233
栈常考面试题有效的括号基本思路方法一：运用stl中的栈写方法二：实现一个栈再写用队列实现栈方法：运用stl中的两个队列实现栈 有效的括号 题目：给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串 s ，判断字符串是否有效。 有效字符串需满足： 左括号必须用相同类型的右括号闭合。 左括号必须以正确的顺序闭合。 示例 1： 输入：s = “()” 输出：true 示例 2： 输入：s = “()[]{}” 输出：true 示例 3： 输入：s = “(]” 输出：false 示例 4：
栈和队列相关面试题
一朵花花
10-03 818
前言： 上篇文章介绍了栈和队列及其相关操作，本篇通过几个面试题，来进一步掌握栈和队列~ 目录括号匹配问题用队列实现栈用栈实现队列实现一个最小栈设计一个循环队列 括号匹配问题 题目：在线OJ 用队列实现栈 题目：在线OJ 用栈实现队列 题目：在线OJ 实现一个最小栈 题目：在线OJ 设计一个循环队列 题目： 在线OJ ...
很好的数据结构面试题(含答案).docx
03-25
"很好的数据结构面试题"文档提供了一系列关于栈、队列和链表的问题，并附有答案。其中，问题1到3涉及栈和队列的特点和存储结构，问题4和5测试对栈的理解，问题6和7探讨链表的特点和优点，问题8和9关注单链表和循环...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值