【栈和队列】常见面试题

于 2024-08-08 14:19:10 发布
阅读量744 收藏 6
点赞数 25
分类专栏： 数据结构 算法 文章标签： 链表 数据结构 c语言 笔记 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2303_79015671/article/details/141025702
版权

文章目录

1.有效的括号

1.1 题目要求

判断所给字符串的括号是否有效。
有效的条件：

  1. 左括号必须用相同类型的右括号闭合。
  2. 左括号必须以正确的顺序闭合。
  3. 每个右括号都有一个对应的相同类型的左括号。

1.2 利用栈解决

遍历给定字符串时，当我们遇到左括号时，把它入栈。目的是为了期望在后续的遍历中有一个相同类型的右括号与其匹配。
当我们遍历时遇到的是右括号，此时有3种情况：
1.栈为空，无法匹配返回false。
2.栈不为空，但不是与之匹配的左括号，返回false。
3.栈不为空，是与之匹配的左括号，继续遍历。
在2，3情况下，为了简化书写，我们可以先把栈顶元素出栈，用一个临时变量保存。
如果我们在遍历时都顺利通过，也不能代表这个字符串就是有效的。
比如这种情况：( ( ( ) )
遍历完后，栈中还会剩下(.
为此最后我们还需要判断栈是否为空，不为空返回false，为空返回true。
注意记得销毁栈

typedef struct stack
{
    char* a;
    int size;//写错了，代表top的意思
    int capacity;
}stack;

void init(stack* ps)
{
    assert(ps);
    ps->a = (char*)malloc(sizeof(char)*4);
    ps->size = 0;
    ps->capacity = 4;
}

bool empty(stack* ps)
{
    return ps->size == 0;
}

void push(stack* ps,char x)
{
    assert(ps);
    if(ps->size == ps->capacity)
    {
        char* tmp = (char*)realloc(ps->a,sizeof(char)*ps->capacity*2);
        if(tmp == NULL)
        {
            perror("realloc");
            exit(-1);
        }
        ps->a = tmp;
        ps->capacity *= 2;
    }
    ps->a[ps->size] = x;
    ps->size+=1;
}
void pop(stack* ps)
{
    assert(ps);
    assert(ps->size>0);
    ps->size -= 1;
}

char Top(stack* ps)
{
    assert(ps);
    assert(ps->size>0);
    return ps->a[ps->size-1];
}
void destory(stack* ps)
{
    assert(ps);
    free(ps->a);
    ps->a = NULL;
    ps->size = 0;
    ps->capacity = 0;
}
bool isValid(char* s) {
    stack st;
    init(&st);
    while(*s)
    {
        if(*s == '('||*s == '['||*s == '{')
            push(&st,*s);
        else if(*s == ')'||*s == ']'||*s == '}')
        {
            if(empty(&st))
            {
                destory(&st);
                return false;
            }
            char top = Top(&st);
            pop(&st);
            if(*s == ')'&&top!='('||*s == ']'&&top!='['||*s == '}'&&top!='{')
            {
                destory(&st);
                return false;
            }
        }
        s+=1;
    }
    if(!empty(&st))
    {
        destory(&st);
        return false;
    }
    destory(&st);
    return true;
}

2. 用队列实现栈

2.1 题目要求

使用两个队列实现一个后入先出（LIFO）的栈

2.2 用队列实现栈

如何用两个队列来实现栈呢？我们知道队列是先进先出的。
先画两个队列出来。
两个队列

此时插入了3个数据，为了让这两个队列实现后进先出的效果，我们得充分利用队列的特性。显然如果是栈，出数据是先出3的，但是队列的话是先出1。为了让队列先出3，我们就要把1和2先移动到另一个空队列中。
操作队列
如此一来，就可以拿到3了。
那么用两个队列实现栈的主要逻辑就出来了。
首先是插入逻辑：有两种情况
1.两个队列都为NULL，随便插入一个队列
2.其中一个队列不为NULL，那么就把数据插入到不为NULL的队列。
然后就是删除逻辑：
在删除时，我们需要把有数据的一方队列的数据转移到没有数据的队列中，直到只剩下一个元素，这就是栈顶元素，用一个临时遍历存储完数据后就可以删除这个栈顶元素了。
再然后的返回栈顶元素：
因为不用删除的缘故，队列又提供返回队尾元素的功能，所以直接返回有数据的那个队尾元素即可。
最后都是一些简单的接口，相信大家没问题的。

typedef struct node
{
    int data;
    struct node* next;
}node;

typedef struct queue
{
    node* head;
    node* tail;
}queue;

void init(queue* q)
{
    assert(q);
    q->head = q->tail = NULL;
}

void push(queue* q,int x)
{
    assert(q);
    node* newnode = (node*)malloc(sizeof(node));
    if(newnode == NULL)
    {
        perror("malloc");
        exit(-1);
    }
    newnode->data = x;
    newnode->next = NULL;
    if(q->head == NULL)
    {
        q->head = q->tail = newnode;
    }
    else
    {
        q->tail->next = newnode;
        q->tail = newnode;
    }
}

void pop(queue* q)
{
    assert(q);
    assert(q->head);
    if(q->head == q->tail)
    {
        free(q->head);
        q->head = q->tail = NULL;
    }
    else
    {
        node* next = q->head->next;
        free(q->head);
        q->head = next;
    }
}

int size(queue* q)
{
    assert(q);
    node* cur = q->head;
    int count = 0;
    while(cur)
    {
        count+=1;
        cur = cur->next;
    }
    return count;
}

bool empty(queue* q)
{
    assert(q);
    return q->head == NULL;
}

int top(queue* q)
{
    assert(q);
    assert(q->head);
    return q->head->data;
}

int back(queue* q)
{
    assert(q);
    assert(q->head);
    return q->tail->data;
}
void destory(queue* q)
{
    assert(q);
    node* cur = q->head;
    while(cur)
    {
        node* next = cur->next;
        free(cur);
        cur = next;
    }
    q->head = q->tail = NULL;
}

typedef struct {
    queue q1;
    queue q2;
} MyStack;


MyStack* myStackCreate() {
    MyStack* s = (MyStack*)malloc(sizeof(MyStack));
    init(&s->q1);
    init(&s->q2);
    return s;
}

void myStackPush(MyStack* s, int x) {
   if(!empty(&s->q1))
   {
        push(&s->q1,x);
   }
   else
   {
        push(&s->q2,x);
   }
}

int myStackPop(MyStack* s) {
    queue* em = &s->q1;
    queue* noem = &s->q2;
    if(!empty(em))
    {
        em = &s->q2;
        noem = &s->q1;
    }
    while(size(noem)>1)
    {
        push(em,top(noem));
        pop(noem);
    }
    int t = top(noem);
    pop(noem);
    return t;
}

int myStackTop(MyStack* s) {
    queue* em = &s->q1;
    queue* noem = &s->q2;
    if(!empty(em))
    {
        em = &s->q2;
        noem = &s->q1;
    }
    return back(noem);
}

bool myStackEmpty(MyStack* s) {
    return empty(&s->q1)&&empty(&s->q2);
}

void myStackFree(MyStack* s) {
    destory(&s->q1);
    destory(&s->q2);
    free(s);
}

3.用栈实现队列

3.1 题目要求

请使用两个栈实现先入先出队列

3.2 用栈实现队列

要用两个后进先出的栈实现先进先出的队列。先看图
两个栈

为了实现队列，我们要把栈设计为一个进进数据栈，一个出数据栈。
当我们需要删除数据时，因为队列先进先出的特性，要出的数据为1，可是栈顶元素是3，所以我们需要把进数据栈的数据全部移动到出数据栈中，移动完后如图：
操作栈

这样的话，程序的主体逻辑都出来了。
开始我们入数据的时候，全部都存储到pusht栈中。
然后当我们想要删除数据/读取队首元素时：会有两种情况
1.popt栈为空，那么我们就把pusht栈中的元素全部转移到popt栈。
2.popt栈不为空，直接取popt的栈顶元素就可以了。
为了简化代码，我们可以复用函数。先实现读取队首元素的功能（peek）再在删除队列元素时复用读取对手元素的功能。详见代码
最后都是写简单功能，大家看代码。

typedef struct stack
{
    int* a;
    int size;//写错了，代表top的意思
    int capacity;
}stack;

void init(stack* ps)
{
    assert(ps);
    ps->a = (int*)malloc(sizeof(int)*4);
    ps->size = 0;
    ps->capacity = 4;
}

bool empty(stack* ps)
{
    return ps->size == 0;
}

void push(stack* ps,int x)
{
    assert(ps);
    if(ps->size == ps->capacity)
    {
        int* tmp = (int*)realloc(ps->a,sizeof(int)*ps->capacity*2);
        if(tmp == NULL)
        {
            perror("realloc");
            exit(-1);
        }
        ps->a = tmp;
        ps->capacity *= 2;
    }
    ps->a[ps->size] = x;
    ps->size+=1;
}
void pop(stack* ps)
{
    assert(ps);
    assert(ps->size>0);
    ps->size -= 1;
}
int Top(stack* ps)
{
    assert(ps);
    assert(ps->size>0);
    return ps->a[ps->size-1];
}
void destory(stack* ps)
{
    assert(ps);
    free(ps->a);
    ps->a = NULL;
    ps->size = 0;
    ps->capacity = 0;
}
int size(stack* ps)
{
    assert(ps);
    return ps->size;
}
typedef struct {
    stack pusht;
    stack popt;
} MyQueue;

MyQueue* myQueueCreate() {
    MyQueue* q = (MyQueue*)malloc(sizeof(MyQueue));
    init(&q->pusht);
    init(&q->popt);
    return q;
}

void myQueuePush(MyQueue* q, int x) {
   push(&q->pusht,x);
}

int myQueuePeek(MyQueue* q) {
    if(empty(&q->popt))
    {
        while(!empty(&q->pusht))
        {
            push(&q->popt,Top(&q->pusht));
            pop(&q->pusht);
        }
    }
    return Top(&q->popt);
}

int myQueuePop(MyQueue* q) {
    int top = myQueuePeek(q);
    pop(&q->popt);
    return top;
}

bool myQueueEmpty(MyQueue* q) {
    return empty(&q->pusht)&&empty(&q->popt);
}
void myQueueFree(MyQueue* q) {
    destory(&q->pusht);
    destory(&q->popt);
    free(q);
    q = NULL;
}

4.设计循环队列

4.1 题目要求

设计一个大小为k的循环队列

4.2 设计循环队列

简单科普循环队列
这是一个循环队列
循环队列

下面展示循环队列为空和为满时情形：
tail位置是不存储数据的，代表意思是队尾元素的下一个。
循环队列的各个情形

科普完成后，下面就是正式的题目讲解：
在初始化时，我们需要开k+1个空间，因为数组中的tial位是不存储数据的。
先写判断循环队列是否为空和为满的功能，写了两个函数书写其他函数时就比较轻松了。
正如上面所说，tail = head为空
为满的话，考虑到循环因素，我们需要利用取模操作。
为满就一种情况，head在tail前面，但是因为数组不像上面画的那样是一个环，所以为满就有了两种情况：
1.tial在head前面，多种情况
2.tail在head后面，在后面就一种情况，tail为k，head为0
(tail+1)%(k+1) = head就是判断条件。
后面的插入删除都没什么难点了，唯一要注意的就是当head和tial到达k时要注意下一步的操作。
还有返回队尾数据的，tail是指向队尾数据的下一个元素的！

typedef struct {
    int* a;
    int head;
    int tail;
    int k;
} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* q = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    q->a = (int*)malloc(sizeof(int)*(k+1));
    q->head = q->tail = 0;
    q->k = k;
    return q;
}
//函数声明
bool myCircularQueueIsEmpty(MyCircularQueue* q);
bool myCircularQueueIsFull(MyCircularQueue* q);


bool myCircularQueueEnQueue(MyCircularQueue* q, int value) {
    if(myCircularQueueIsFull(q))
        return false;
    q->a[q->tail] = value;
    if(q->tail == q->k)
        q->tail = 0;
    else
        q->tail+=1;
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* q) {
    if(myCircularQueueIsEmpty(q))
        return false;
    if(q->head == q->k)
        q->head = 0;
    else
        q->head+=1;
    return true;
}

int myCircularQueueFront(MyCircularQueue* q) {
    if(myCircularQueueIsEmpty(q))
        return -1;
    return q->a[q->head];
}

int myCircularQueueRear(MyCircularQueue* q) {
    if(myCircularQueueIsEmpty(q))
        return -1;
    if(q->tail == 0)
        return q->a[q->k];
    else
        return q->a[q->tail-1];
}

bool myCircularQueueIsEmpty(MyCircularQueue* q) {
    if(q->head == q->tail)
        return true;
    return false;
}

bool myCircularQueueIsFull(MyCircularQueue* q) {
    if((q->tail+1)%(q->k+1) == q->head)
        return true;
    return false;

}

void myCircularQueueFree(MyCircularQueue* q) {
    free(q);
    q = NULL;
}

完

Yui_
关注
  • 25
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 5
    评论
专栏目录
Java实现栈和队列面试题
09-03
以上就是Java实现栈和队列面试题的主要内容。理解和熟练掌握这些知识点对于Java开发者来说至关重要，因为它们涉及到基础数据结构的运用，能够反映候选人在解决实际问题时的逻辑思维和算法能力。在面试中，候选人可能...
Java面试常见面试题
03-06
10. **数据结构与算法**：面试中还会涉及到基本的数据结构（数组、链表、栈、队列、树等）和算法（排序、查找、图论等），这些都是解决复杂问题的基础。 以上各个领域的知识不仅是面试的重点，也是实际开发中不可或...
《互联网面试笔记》收集和分析互联网常见面试题.zip
11-14
《互联网面试笔记》收集和分析了互联网领域，特别是针对Python编程语言的常见面试题，旨在帮助程序员在应聘过程中提升自身的知识水平和技能准备。这份资料不仅涵盖了基础的Python语法，还包括了高级特性、数据结构、...
java集合常见面试题.rar
03-24
本压缩包文件"java集合常见面试题.rar"包含了针对这个主题的常见问题及答案解析，旨在帮助求职者准备相关面试。 1. **集合接口** - **List**：有序的集合，元素可以重复，允许有重复的元素，例如ArrayList和...
java常见面试题
11-05
Java作为一门广泛使用的编程语言，其面试题涵盖了基础语法、数据结构、算法、多线程、JVM优化、集合框架、网络编程、设计模式等多个方面。以下是对这些常见面试题目的详细解读： 1. **基础语法**：这部分通常包括...
单链表-数据结构
qq_31804097的博客
08-07 113
【代码】单链表、双向带头循环链表-数据结构。
数据结构初阶：栈和队列
LCL200356的博客
08-03 865
栈的结构的定义和顺序表结构定义一样，在栈中定义一个指针data用于操作数据，然后定义整型变量capacity用于表示栈的空间大小，最后定义一个整型变量top用于表示有效数据个数也就是我们的栈顶。//定义一个栈的结构//数组//栈的空间的大小int top;//有效数据个数}ST;队列的结点结构就是单链表结点结构，队列结构phead指向头结点和ptail指向尾结点，还有一个size用同统计结点个数。//链式结构表示队列}QNode;//队列结构int size;//计数器。
算法回忆录（2）
m0_73399576的博客
08-05 1182
算法回忆录（2）
【数据结构-前缀哈希】力扣525. 连续数组
最新发布
sjsjs11的博客
08-07 94
将nums中的0全部替换成-1，然后定义一个哈希表group，键用来储存sum，值用来储存对应的前缀和的下标。当前计算前缀和sum的时候，如果前面有相同的前缀和，说明中间这个子段和为0，也就说明0和1的数量相等，所以这个时候。给定一个二进制数组 nums , 找到含有相同数量的 0 和 1 的最长连续子数组，并返回该子数组的长度。说明: [0, 1] (或 [1, 0]) 是具有相同数量0和1的最长连续子数组。说明: [0, 1] 是具有相同数量 0 和 1 的最长连续子数组。来求这个子段的长度。
[C++进阶&数据结构]二叉搜索树
2301_80017277的博客
08-07 851
对于二叉树的结点，我们类似于list的结点定义一样，使用一个struct类。
理解栈（Stack）及其在 C++ 中的应用【栈、数据结构】
qq_22841387的博客
08-07 297
栈是一种数据结构，它遵循“后进先出”（LIFO - Last In, First Out）的原则。栈就像是一叠盘子，你只能从最上面拿盘子，也只能在最上面放盘子。栈的这一特性使其在很多场景中非常有用，例如递归、回溯算法和表达式计算等。通过这篇博客，我们详细介绍了栈的基本概念及其在 C++ 中的实现。栈是一种非常有用的数据结构，尤其在处理递归、回溯和表达式计算等问题时。我们还讨论了如何将栈中的字符转换为字符串，以及如何使用栈解决括号匹配问题。
从零开始学数据结构系列之第四章《迪杰斯特拉算法了解》
铁匠匠匠的博客
08-04 1097
1、先选定一个根结点，并选定一个数组，先确定未遍历前的初始距离，把距离最短的邻接结点选定为中间结点，并标记访问过，开始往下遍历，挨个访问那个中间结点的邻接结点。计算出根结点到中间结点+中间结点到新邻接结点的距离，作为新距离，对比新距离和旧距离，如果新距离大，则把新距离替换掉旧距离，否则不变。算法的基本思想是：从源点出发，每次选择离源点最近的一个顶点前进，然后以该顶点为中心进行扩展，最终得到源点到其余所有点的最短路径。2、一轮访问结束后，从未标记的结点中选定距离最短的，把它作为中间结点，继续往下访问。
数据结构 | 考研代码题之顺序表 | 1 查找L中值为e的数据元素若找到则返回其下标，若找不到则返回-1
猫天意的博客
08-04 208
假设有一个顺序表 L，其存储的所有数据元素均为不重复的正数，查找L中值为e的数据元素，若找到则返回其下标，若找不到则返回-1。
数据结构图书管理系统
2305_78057683的博客
08-07 166
数据结构图书管理系统
【算法模板】数据结构：三分查找
2303_80346267的博客
08-07 558
算法竞赛中的三分（ternary search）是一种用于在单峰函数（unimodal function）上找到最大值或最小值的搜索算法。与二分搜索（binary search）类似，三分搜索在每次迭代中将搜索空间分成三个部分，但三分搜索用于连续区间而不是离散区间。
数据结构第十讲：二叉树OJ题
2301_79761834的博客
08-04 676
数据结构第十讲：二叉树OJ题
数据结构：二叉树
LCL200356的博客
08-07 846
/创建堆结构int size;}HP;
【数据结构】数据结构的基本概念
zhousanguhe的博客
08-03 370
数据结构的基本概念
数据结构(8):排序
qq_64279967的博客
08-04 1063
前面时 保存好的 是排好序的哦 一个一个检查！然后放到改在的位置只有小的时候换，等于的时候不换，这样可以保证算法的稳定性这样的话 插入排序的效率就会高一点！每一趟都会使最小的数冒在前面！相同的话不冒 保证算法的稳定性没有发生交换，算法就结束！！！！flag变量！！时间复杂度不会因为所给序列特点不同而出现不同的时间复杂度！对于n个序列就要进行n-1次对比所以排序时 也是在每一趟的待排序元素中选取关键字最小(或最大)的元素加入有序子序列！堆顶的元素时最大的 所以一切都变得很简单了。
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Yui_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值