栈常见的面试题

最新推荐文章于 2023-09-05 09:47:58 发布
最新推荐文章于 2023-09-05 09:47:58 发布
阅读量964 收藏 7
点赞数
分类专栏： 工欲善其事 文章标签： 数据结构 栈 面试题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Cyrus_wen/article/details/80082197
版权

之前我们学习了栈，现在介绍一下栈常见的面试题。
常见面试题之一：
最小栈

实现一个栈，要求实现Push(出栈)、Pop(入栈)、Min(返回最小值)的时间 复杂度为O(1）
关于如何实现最小栈，我们有两种思路。
思路一：我们设置两个栈，一个栈存放最小元素，另外一个栈存放栈内的数据。
思路二：我们利用一个栈，每次入栈时都入两个元素，第一个是要入栈的元素，出栈时也出两个元素，这样，栈顶元素就一直是最小元素。

这里写图片描述
其实思路一和思路二的思想是一样的，接下来我们用代码来实现一下思路二。
这部分关于链式栈的操作我就不在这里赘述了，详细的介绍可以看
我的博客:链式栈的基本操作


#include"linkstack.h"

void LinkStackInit(LinkStack* q){
    if(q == NULL){
        return;
    }
    q->head = NULL;
    q->tail = NULL;
    return;
}

LinkNode* LinkStackCreateNode(LinkStackType value){
    LinkNode* new_node = (LinkNode*)malloc(sizeof(LinkNode));
    if(new_node == 0){
        return NULL;
    }
    new_node->next = NULL;
    new_node->data = value;
    return new_node;
}

void DestroyNode(LinkNode* to_delete){
    if(to_delete == NULL){
        return;
    }
    free(to_delete);
    return;
}

void LinkStackPush(LinkStack* q,LinkStackType value){
    if(q == NULL){
        return;
    }
    LinkNode* new_node = LinkStackCreateNode(value);
    if(q->head == NULL){
        q->head = new_node;
        q->tail = new_node;
        return;
    }
    q->tail->next = new_node;
    q->tail = q->tail->next;
    return;
}

void LinkStackPrint(LinkStack* q,const char* msg){
    if(q == NULL){
        return;
    }
    printf("[ %s ]:\n",msg);
    LinkNode* cur = q->head;
    while(cur != NULL){
        printf("[%c][%p]->",cur->data,cur);
        cur = cur->next;
    }
    printf("NULL\n\n");
    return;
}

void LinkStackPop(LinkStack* q){
    if(q == NULL){
        return;
    }
    if(q->head == NULL){
        return;
    }
    LinkNode* temp = q->tail;
    LinkNode* cur = q->head;
    while(cur->next != q->tail){
        cur = cur->next;
    }
    q->tail = cur;
    q->tail->next = NULL;
    DestroyNode(temp);
    return;
}

int LinkStackFront(LinkStack* q,LinkStackType* value){
    if(q == NULL){
        return 0;
    }
    *value = q->tail->data;
    return 1;
}


//接下来是最小栈的具体实现

void MinStackPush(LinkStack* q,LinkStackType value){
    if(q == NULL){
        return;
    }
    if(q->head == NULL){
    //如果栈为空，默认第一个元素就是最小值，入栈两次
        LinkNode* new_node1 = LinkStackCreateNode(value);
        LinkNode* new_node2 = LinkStackCreateNode(value);
        q->head = new_node1;
        q->head->next = new_node2;
        q->tail = new_node2;
        return;
    }
    LinkStack* cur = q;

    //如果栈顶元素大于value说明value就是当前栈最小的值
    if(cur->tail->data > value){
        LinkNode* new_node1 = LinkStackCreateNode(value);
        LinkNode* new_node2 = LinkStackCreateNode(value);
        cur->tail->next = new_node1;
        cur->tail = cur->tail->next;
        cur->tail->next = new_node2;
        cur->tail = cur->tail->next;
        return;
    }else{
        LinkNode* new_node1 = LinkStackCreateNode(value);
        LinkNode* new_node2 = LinkStackCreateNode(cur->tail->data);
        cur->tail->next = new_node1;
        cur->tail = cur->tail->next;
        cur->tail->next = new_node2;
        cur->tail = cur->tail->next;
        return;
    }
    return;
}

void MinStackPop(LinkStack* q){
    if(q == NULL){
        return;
//每次出栈两个元素
    LinkStackPop(q);
    LinkStackPop(q);
    return;
}

//这里我们采用输出型参数 value 将最小值取出来
int MinStack(LinkStack* q,LinkStackType* value){
    if(q == NULL || value == NULL){
        return 0;
    }
    *value = q->tail->data;
    printf("栈顶元素是：%c\n",q->tail->data);
    return 1;
}

常见栈的面试题之二：
使用两个栈实现一个队列

关于两个栈实现一个队列，栈是先进后出，队列是先进先出，所以我们考虑建立两个栈，每次将一个栈的元素出栈然后入栈第二个栈，这样再出栈第二个栈的元素就是前面先入栈的元素了，这样就可以模拟出来一个队列。但是考虑到一次队列后再入队列的时候可能导致顺序混乱，我们需要将第二个栈里的元素入栈回第一个栈才能继续入队列。

这里写图片描述
这里写图片描述
这里写图片描述
这里写图片描述

接下来，我们用代码来实现一下上面的过程：

#include"linkstack.h"

void LinkStackInit(LinkStack* q){
    if(q == NULL){
        return;
    }
    q->head = NULL;
    q->tail = NULL;
    return;
}

LinkNode* LinkStackCreateNode(LinkStackType value){
    LinkNode* new_node = (LinkNode*)malloc(sizeof(LinkNode));
    if(new_node == 0){
        return NULL;
    }
    new_node->next = NULL;
    new_node->data = value;
    return new_node;
}

void DestroyNode(LinkNode* to_delete){
    if(to_delete == NULL){
        return;
    }
    free(to_delete);
    return;
}

void LinkStackPush(LinkStack* q,LinkStackType value){
    if(q == NULL){
        return;
    }
    LinkNode* new_node = LinkStackCreateNode(value);
    if(q->head == NULL){
        q->head = new_node;
        q->tail = new_node;
        return;
    }
    q->tail->next = new_node;
    q->tail = q->tail->next;
    return;
}

void LinkStackPrint(LinkStack* q,const char* msg){
    if(q == NULL){
        return;
    }
    printf("[ %s ]:\n",msg);
    LinkNode* cur = q->head;
    while(cur != NULL){
        printf("[%c][%p]->",cur->data,cur);
        cur = cur->next;
    }
    printf("NULL\n\n");
    return;
}

void LinkStackPop(LinkStack* q){
    if(q == NULL){
        return;
    }
    if(q->head == NULL){
        return;
    }
    LinkNode* temp = q->tail;
    LinkNode* cur = q->head;
    if(temp == cur){
        DestroyNode(temp);
        q->head = NULL;
        return;
    }
    while(cur->next != q->tail){
        cur = cur->next;
    }
    q->tail = cur;
    q->tail->next = NULL;
    DestroyNode(temp);
    return;
}

int LinkStackFront(LinkStack* q,LinkStackType* value){
    if(q == NULL){
        return 0;
    }
    *value = q->tail->data;
    return 1;
}

//交换栈元素栈内元素
void ChangeStack(LinkStack* q1, LinkStack* q2){
    if(q1 == NULL || q2 == NULL){
        return;
    }
    LinkStackType value;
    while(q2->tail != q2->head){
        value = q2->tail->data;
        LinkStackPop(q2);
        LinkStackPush(q1, value);
    }
    value = q2->head->data;
    LinkStackPop(q2);
    LinkStackPush(q1, value);
    return;
}

void QueueByStackPush(LinkStack* q1, LinkStack* q2,  LinkStackType value ){
    if(q1 == NULL || q2 == NULL){
        return;
    }

    //入栈时判断哪个栈是空的，将不是空的栈的元素导入到空的栈
    if(q1->head == NULL && q2->head != NULL){
        ChangeStack(q1, q2);
        LinkStackPush(q1, value);
        ChangeStack(q2, q1);
        return;
    }else{
        LinkStackPush(q1,value);
        ChangeStack(q2, q1);
        return;
    }
    return;
}

void QueueByStackPop(LinkStack* q1,LinkStack* q2){
    if(q1 == NULL || q2 == NULL){
        return;
    }
    //出栈只要将栈2的栈定元素出栈就ok
    LinkStackPop(q2);
    return;
}

常见题型之三
两个队列实现一个栈
在这道题目中我们考虑到栈是先进后出的，而队列是先进先出的，因此，我们同样考虑用两个队列来模拟实现一个栈。首先将不为空的一个队列的元素出队列到另外一个队列，直到该队列只剩一个元素，然后将该元素出栈，我们就模拟实现了先进先出，也就是队列的基本形式。
这里写图片描述

#include"linkqueue.h"

void LinkQueueInit(LinkQueue* q){
    if(q == NULL){
        return;
    }
    q->head = NULL;
    q->tail = NULL;
    return;
}

LinkNode* LinkQueueCreateNode(LinkQueueType value){
    LinkNode* new_node = (LinkNode*)malloc(sizeof(LinkNode));
    if(new_node == 0){
        return NULL;
    }
    new_node->next = NULL;
    new_node->data = value;
    return new_node;
}

void DestroyNode(LinkNode* to_delete){
    if(to_delete == NULL){
        return;
    }
    free(to_delete);
    return;
}

void LinkQueuePush(LinkQueue* q,LinkQueueType value){
    if(q == NULL){
        return;
    }
    LinkNode* new_node = LinkQueueCreateNode(value);
    if(q->head == NULL){
        q->head = new_node;
        q->tail = new_node;
        return;
    }
    q->tail->next = new_node;
    q->tail = q->tail->next;
    return;
}

void LinkQueuePrint(LinkQueue* q,const char* msg){
    if(q == NULL){
        return;
    }
    printf("[ %s ]:\n",msg);
    LinkNode* cur = q->head;
    while(cur != NULL){
        printf("[%c][%p]->",cur->data,cur);
        cur = cur->next;
    }
    printf("NULL\n\n");
    return;
}

void LinkQueuePop(LinkQueue* q){
    if(q == NULL){
        return;
    }
    if(q->head == NULL){
        return;
    }
    LinkNode* temp = q->head;
    q->head = q->head->next;
    DestroyNode(temp);
    return;
}

int LinkQueueFront(LinkQueue* q,LinkQueueType* value){
    if(q == NULL){
        return 0;
    }
    *value = q->head->data;
    return 1;
}

//#######################################################################################################
//############################# 两个队列实现一个栈 ######################################################
//#######################################################################################################

//搬移两个队列的内容，直到一个队列只剩一个元素
LinkQueue* MvStackByQueue(LinkQueue* from, LinkQueue* to){
    if(from == NULL || to == NULL){
        return NULL;
    }
    LinkQueueType value;
    while(from->head != from->tail){
       value =  from->head->data;
       LinkQueuePop(from);
       LinkQueuePush(to,value);
    }
    return from;
}

void StackByQueuePush(LinkQueue* from, LinkQueue* to, LinkQueueType value){
    if(from == NULL || to == NULL){
        return;
    }
    if(from->head == NULL && to->head != NULL){
        LinkQueuePush(to, value);
        return;
    }else{
        LinkQueuePush(from, value);
    }
    return;
}

int StackByQueuePop(LinkQueue* from, LinkQueue* to, LinkQueueType* value){
    if(from == NULL || to == NULL || value == NULL){
        return 1;
    }
    if(from->head == NULL && to->tail != NULL){
        LinkQueue* top = MvStackByQueue(to, from);
        *value = top->head->data;
        LinkQueuePop(to);
    }else{
        LinkQueue* top = MvStackByQueue(from, to);
        *value = top->head->data;
        LinkQueuePop(from);
    }
    return 1;
}

常见栈的面试题之四
共享栈
一个数组实现两个栈(共享栈)
这里写图片描述
设置两个指针top1 和 top2分别指向数组头和数组尾，插入元素的时候两个指针分别向中间移动，当两个指针相遇的时候说明共享栈已满。
代码的实现需要参考栈的范围设置。
这里，我们设置栈一的取值范围是[0, top1）,栈二的取值范围时候[top2,MAXSIZE)
具体实现如下：

#include"share_stack.h"

void ShareStackInit(ShareStack* stack){
    if(stack == NULL){
        return;
    }
    stack->top1 = 0;
    stack->top2 = ShareStackMaxSize;
    return;
}

void ShareStackPush1(ShareStack* stack, ShareStackType value){
    if(stack == NULL){
        return;
    }
    if(stack->top1 >= stack->top2){
        //栈满
        return;
    }
    stack->data[stack->top1++] = value;
    return;
}

void ShareStackPush2(ShareStack* stack,ShareStackType value ){
    if(stack == NULL){
        return;
    }
    if(stack->top1 >= stack->top2){
        return;
    }
    stack->data[--stack->top2] = value;
    return;
}

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

void ShareStackPop2(ShareStack* stack){
    if(stack == NULL){
        //非法输入
        return;
    }
    if(stack->top2 == ShareStackMaxSize){
        //空栈
        return;
    }
    ++stack->top2;
}

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

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

以上就是栈的常见部分面试题解答，由于本人能力有限，可能在上面的介绍中有一些不妥或者bug，欢迎发邮件到我的邮箱（Cyrus_wen@163.com）批评指正！

Cyrus_wen
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
几个有关栈的题目
iDJ77的博客
01-25 6921
例题 设栈的顺序存储空间为S（1：50），初始状态为top=-1。现经过一系列正常的入栈与退栈操作后，top=30，则当前栈中的元素个数为（　D　）。 A.20 B.19 C.31 D.30 设栈的顺序存储空间为S（1：m），初始状态为top=m+1，则栈中的数据元素个数为（　B　）。 A.top-m+1 B.m-top+1 C.m-top D.top-m 设栈的顺序存储空间为S（1：50），初始状态为top=-1。现经过一系列正常的入栈与退栈操作后，top=30，则当前栈中的元素个数为（　B　）。 A.
关于栈常见的面试题
PYTHON的博客
07-23 647
* 实现一个栈，要求实现push(入栈)、Pop(出栈)、Min(返回最小值)的时间复杂度为O(1)* 法1：分析：将元素与最小值封装成一个结构体 头文件： StackAndQueueInterview.h： // 将元素与最小值封装成一个结构体 typedef struct Elem { ElemType _data; ElemType _minData; }Elem; ...
【数据结构练习】栈的面试题集锦
WHabc2002的博客
09-05 891
数据结构想要学的好，刷题少不了，我们不仅要多刷题，还要刷好题！为此我开启了一个必做好题锦集的系列，此为第一篇选择题篇，该系列会不定期更新敬请期待！栈（Stack）的详解_WHabcwu的博客-CSDN博客。
移动应用开发常见面试题.pdf
最新发布
04-10
- 1. 请简要介绍一下移动应用开发的流程和技术栈。 - 2. 移动应用开发中常用的平台有哪些？分别介绍 Android 和 iOS 平台。 - 3. Android 和 iOS 平台之间有何区别？请比较两者的开发语言、开发工具等方面。 - 4. 在移动应用开发中，什么是原生应用（Native App）、混合应用（Hybrid App）和Web 应用（Web App）？它们各有什么特点？ - 5. 移动应用开发中常用的开发语言有哪些？请简要介绍 Java、Kotlin、Swift 和 Objective-C。 - 6. 移动应用开发中的常用开发框架有哪些？请说明在移动应用开发中常用的框架。 - 7. 什么是跨平台移动应用开发（Cross-platform Mobile App Development）？请说明跨平台开发的优势和劣势。 - 8. 在移动应用开发中，什么是 MVP、MVVM 和 MVC 架构模式？请说明三种架构模式的特点。 - 9. 移动应用开发中如何进行用户界面设计和交互设计？请说明在移动应用开发中的设计原则。 - 10. 移动应用开发中如何处理数据存储和管理？请说明在移
（C语言版）力扣（LeetCode）栈和队列面试题
立志做一个高产且细节博主
05-13 1276
20. 有效的括号 解法一：建立栈解决 解法二：数组模拟栈解决 225. 用队列实现栈 解法：两个队列实现栈 232. 用栈实现队列 解法：两个栈实现队列 622. 设计循环队列
栈和队列经典面试题
m0_74444368的博客
08-11 401
定义两个数组下标，front指向队列的头，back指向队尾的下一个位置，原因：back最开始只能指向数组的第一个位置，也就是下标为0的位置，插入一个元素之后，back向后移一个位置，如果back指向的就是队尾的最后一个元素，那最开始队列为空的时候back指向哪里呢？所以就矛盾了（用链表实现也是同理）int* a;int front;int back;int k;
【数据结构】这些栈、队列的经典面试题你还不知道吗？
Living_Amethyst的博客
06-22 251
力扣在做这道题前，我们需要有 栈 的先驱知识，可以参考本人的这篇博客(41条消息) 【数据结构】栈_Living_Amethyst的博客-CSDN博客 分析：由于队列的特点是“先进先出”，而栈的特点是“后入先出”，所以用队列实现栈 仅用一个队列是不能实现的，需要两个队列我们的思路是：入的时候都入到不为空的队列里，出的时候就把不为空的队列里的除了要出的元素之外的其他(size-1)个元素都移到为空的队列里 二.用栈实现队列 力扣 分析：和上一题类似，若要用栈实现队列，我们需要两个栈
关于栈的常见编程题
ting_happy的博客
09-18 982
而同理，如果是让我们求前缀表达式的值，我们应从后往前遍历前缀表达式，将数字放入栈中，而碰到运算符，则弹出栈顶元素，注意：先弹出的元素此时应该放运算符的左边，后弹出的元素应该放运算符的右边，重复上述步骤，知道前缀表达式走完。此时我们可以利用栈先入后出的特性，以"({[]})"为例，先在栈中压入"("，后看剩余字符串中的第一个元素是否与栈顶元素相匹配，如果不匹配，则入栈，否则出栈，到下一个字符。给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。
算法学习笔记——栈的经典问题
xuanyue_18的博客
08-06 322
栈有很多典型的题目，这些题目整体难度不算很大，但是对于刚刚开始刷算法的同学来说，还是会感到比较吃力，这一章，我们就来盘点几个经典的高频栈算法问题。
【刷题总结】栈系列问题
迈向年薪百万之路
06-07 445
文章目录一、算法介绍二、解题模板1、栈的实现2、栈的API3、深度优先4、单调栈问题三、栈系列问题1、栈的基础特征（1）设计题，用来实现其他结构（2）利用栈的基础特征2、括号&表达式运算&退格问题（1）括号匹配问题（2）表达式运算问题（3）退格问题3、单调栈4、树的遍历-深度优先5、图的遍历-深度优先 一、算法介绍 栈：后入先出 栈系列问题：https://leetcode-cn.com/tag/stack/problemset/ 栈的典型问题 设计题 括号、表达式运算、字符串
栈——经典面试题（1）
10-17
题目：输入两个整数序列，第一个表示栈的压入顺序，请判断第二序列是否为该栈的弹出序列，假设压入栈的所有数字均不相等。--java实现
【经典面试题】单链表的常见面试题
01-20
单链表的常见面试题有如下： 1.求单链表中有效节点的个数 2.查找单链表中倒数第k个节点【新浪面试题】 3.单链表的反转【腾讯面试题】 4.从尾到头打印单链表【百度，要求方式1：反向遍历。方式2：Stack栈】 5.合并两...
常见的Java面试题与答案解析.docx
04-11
# 基于常见的Java面试题与答案解析的毕业设计实现 此毕业设计旨在帮助Java开发者准备面试，提高面试通过率。项目包括以下内容： ## 1. Java面试题库 建立一个包含常见Java面试题的题库，题目涵盖Java基础、多线程...
30道 C++ 常见面试题
04-05
这个PDF文档是一份精心整理的C++常见面试题集。文档包含了30个经典的C++面试问题，涵盖了C++的基础知识、面向对象特性、内存管理、类型安全、函数调用和返回值等多个方面。这些问题不仅适合用于面试准备，也有助于...
互联网公司Java面试题及核心知识点
06-26
内容概要:本书从近一百套最新一线互联网公司面试题中精选而出，涵盖Java架构面试所有技术栈，包 括JVM，Mysql，并发，Spring，Mybatis，Redis，MQ，Zookeeper，Netty， Dubbo，Spring Boot，Spring Cloud，数据结构...
栈与栈的经典面试题
VIBE的博客
09-25 1236
一次保存单个同类型元素，多个元素之间逻辑上连续例如：数组，链表，栈，队列，字符串（内部就是char[]）上述讲的数组也罢，链表也罢，既可以在头部插入和删除，也能在尾部插入和删除，甚至可以在任意位置都可以插入和删除。"栈和队列"只能在一端插入元素和删除元素。
堆栈相关面试题（详解）
smile_zhangw的博客
08-29 4890
1. 实现一个栈，要求实现Push（出栈）、Pop(入栈)、Min(返回最小值的操作)时间复杂度为O(1)。 分析：设计两个栈，一个栈用来push 、pop操作，另一个栈用来保存当前最小值Min。当push元素小于等于Min栈顶元素时，将其压入Min栈顶，当pop元素等于Min栈顶元素时，两个栈均要pop出栈顶元素。下图为各种情况的优缺点分析。 class StackWithMin { ...
栈的面试题总结
fern_girl的博客
05-16 332
1.不用辅助空间实现栈的逆序（利用函数的递归） 例如栈中元素1 2 3 4，逆序后栈中元素为4 3 2 1int GetLastNumOfStack(stack<int>& s)// 得到栈顶的元素 { int result = s.top();//取栈顶元素 s.pop();//出栈 if(s.empty()==true) return result;//
spring技术栈面试题
08-17
当谈到Spring技术栈的面试题时，有很多常见的问题可以问。这里是一些可能的问题： 1. 什么是Spring框架？它的主要特点是什么？ 2. Spring框架中的核心模块是什么？你能列举一些核心模块吗？ 3. 什么是依赖注入（Dependency Injection）？Spring框架中如何实现依赖注入？ 4. 什么是面向切面编程（AOP）？Spring框架中如何使用AOP？ 5. Spring中的Bean是什么？如何定义和配置一个Bean？ 6. Spring MVC是什么？它与其他MVC框架有什么区别？ 7. 请解释一下Spring中的IoC（Inversion of Control）是什么意思。 8. 什么是Spring Boot？它与Spring框架有什么区别？ 9. Spring框架中的常用注解有哪些？请解释它们的作用。 10. 如何在Spring中处理事务？ 这些问题只是一些基本的示例，实际面试中可能会问到更深入和具体的问题。建议在面试前对Spring框架进行全面的复习和准备，以确保能够回答各种类型的问题。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值