栈和队列专题（LeetCode）

最新推荐文章于 2024-07-19 19:25:43 发布
最新推荐文章于 2024-07-19 19:25:43 发布
阅读量1.9k 收藏 42
点赞数 55
文章标签： leetcode linux 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79722622/article/details/139040184
版权

目录

有效的括号

在这里插入图片描述

题解

左括号从s字符串中取出来放入栈中
s中就只有右括号了
那么栈顶的左括号和s的右括号匹配即可
代码中也详细解释了左括号和右括号多少的问题

代码加解释

bool isValid(char* s) 
{
    Stack sl;
    StackInit(&sl);
    while(*s)
    {
        //先插入左括号
        if(*s == '('||
           *s == '{'||
           *s == '[')
           {
             StackPush(&sl,*s);
           }
        else//右括号取栈顶左括号尝试匹配
        {
           if(STEmpty(&sl))
           {
            //解决右括号比左括号多的情况
            //s中只有右括号，top == 0
            StackDestroy(&sl);
            //释放sl指向的空间
            return false;
           }
           //取栈顶数据
           char top = STTop(&sl);
           //把栈顶的括号取出来和右括号匹配
           StackPop(&sl);
           //弹出栈顶数据，方便取下一个数据
           //不匹配
           if(top == '('&& *s != ')'||
              top == '['&&*s != ']'||
              top == '{'&&*s != '}')
              {
                StackDestroy(&sl);
                return false;
              }
        }
        s++;
    }
    
    //栈不为空，左括号的数量比右括号的数量多，数量不匹配
    //只有一个左括号,假
    //解决的是右括号和左括号一样多和左括号多的情况
    bool ret = STEmpty(&sl);
    //栈为空，top == 0，真
    StackDestroy(&sl);
    return ret; 
}

用队列实现栈

请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。

实现 MyStack 类：

void push(int x) 将元素 x 压入栈顶。
int pop() 移除并返回栈顶元素。
int top() 返回栈顶元素。
boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。

注意：

你只能使用队列的标准操作 —— 也就是 push to back、peek/pop from front、size 和 is empty 这些操作。
你所使用的语言也许不支持队列。 你可以使用 list （列表）或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。

示例：

输入：
[“MyStack”, “push”, “push”, “top”, “pop”, “empty”]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 2, 2, false]

解释：
MyStack myStack = new MyStack();
myStack.push(1);
myStack.push(2);
myStack.top(); // 返回 2
myStack.pop(); // 返回 2
myStack.empty(); // 返回 False

提示：

1 <= x <= 9
最多调用100 次 push、pop、top 和 empty
每次调用 pop 和 top 都保证栈不为空

进阶：你能否仅用一个队列来实现栈。

题解

实现各个接口，用两个队列实现栈
主体思路还是保证一个队列是空的，一个队列是非空的
空的队列用于导数据，比如非空队列 1 2 3 4,1 2 3导到空的队列中，4直接pop,对应栈顶的删除
非空的队列直接插入数据，因为队列是尾插，也就是栈顶的插入
在这里插入图片描述
MyStack下有一个重要的说明
1.后取地址，相当于开了一个新的队列，在新的队列中许多值是未定义的，相当于随机值，所以不能后取地址
在这里插入图片描述

2.先取地址，是对原队列进行操作，指针指向原队列
在这里插入图片描述

代码加解释

//C语言要造轮子，前面的接口在上一个博客，需要的可以自取
typedef struct 
{
  Queue q;//队列1
  Queue p;//队列2
} MyStack;

MyStack* myStackCreate() 
{
    //一个队列为空，另一个队列为有数据
    //把数据插入非空队列中，空的队列用来导数据
    MyStack* obj = (MyStack*)malloc(sizeof(MyStack));
    //不能和题里创建一样的指针，重定义
    QueueInit(&(obj->p));
    QueueInit(&(obj->q));
    //初始化队列1和队列2

    return obj;
}

void myStackPush(MyStack* obj, int x) 
{
    if(!QueueEmpty(&(obj->p)))
    {
        QueuePush(&(obj->p),x);
        //第一个队列是非空的就插入第一个队列中
    }   
    else//1.p空q非空，插入队列q 2.p空q空，这种随便插入那个队列
    {
        QueuePush(&(obj->q),x);
    }
}

int myStackPop(MyStack* obj) 
{
    //你不知道q,p那个队列是空，所以要假设
    //用空队列导一下
    //假设法，假设队列p为非空，队列q为空
    Queue* Noempty = &(obj->p);
    Queue* Empty = &(obj->q);
    if(!QueueEmpty(&(obj->q)))
    {
        Empty = &(obj->p);
        Noempty = &(obj->q);
    }   
    
    while(QueueSize(Noempty) > 1)
    {
      QueuePush(Empty, QueueTop(Noempty));
       QueuePop(Noempty);
       //卡在这个地方，把对头数据取出来，然后头删，再尾插入空的队列
    }
    
    int top = QueueTop(Noempty);
    QueuePop(Noempty); 
    //把栈顶数据取出来，返回栈顶数据
    //再删掉最后的栈顶数据    

    return top;
}

int myStackTop(MyStack* obj) 
{
    if(!QueueEmpty(&(obj->q)))
    {
        return QueueTail(&(obj->q));
    }  
    else
    {
        return QueueTail(&(obj->p));
    }
}

bool myStackEmpty(MyStack* obj) 
{
   return QueueEmpty(&(obj->q)) && QueueEmpty(&(obj->p));    
}

void myStackFree(MyStack* obj) 
{
   QueueDestroy(&(obj->q));
   QueueDestroy(&(obj->p));

   free(obj);    
}

/**  * Your MyStack struct will be instantiated and called as such:
 * MyStack* obj = myStackCreate();
  * myStackPush(obj, x);
 
  * int param_2 = myStackPop(obj);
 
  * int param_3 = myStackTop(obj);
 
  * bool param_4 = myStackEmpty(obj);
 
  * myStackFree(obj);
 */

设计循环队列

在这里插入图片描述

题解

主要多开一个空间为了解决假溢出问题
代码里也有写

队列为空 -> head == tail
在这里插入图片描述

队列为满 -> （tail+1）% （k+1） == head
%k+1 为了解决回绕问题
普通的情况tail + 1 = head
在这里插入图片描述

  • 插入数据 -> (obj->tail) %= (obj->k+1);
    tail++ 变成5又要解决回绕问题，%k+1回到0位置可以插入数据
  • 删除数据 -> obj->head %= (obj->k+1)
    head++ 变成5又要解决回绕问题，%k+1回到0位置可以删除数据
  • 取队头数据 -> obj->a[obj->head]
    head指向头直接取队头数据
  • 取队尾数据 ->
    1.return obj->a[(obj->tail-1 + obj->k+1) % (obj->k+1)]
    2.return obj->tail == 0 ? obj->a[obj->k] : obj->a[obj->tail-1]

tail是指向队尾的下一个位置
取队尾数据要tail - 1，但是tail == 0时，tail - 1就会越界，
tail == 0时要回绕到 tail == k 是队尾数据的下标

有两种方法可以理解第二种比较好理解
第一种取一个数据也比较好理解
比如tail = 0,k = 4 时，-1+5 = 4 % k+1 = 4,就取到队尾的下标了

代码加解释

typedef struct 
{
  int* a;
  int head;//指向头
  int tail;//指向尾
  int k;     
} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k) 
{
    
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->a = (int*)malloc(sizeof(int)*(k+1));
    //多开一个空间，为了解决循环队列的假溢出问题
    //假溢出问题：比如开四个空间，head == tail是空，head == tail也是满
    obj->head = 0;
    obj->tail = 0;    
    obj->k = k;

    return obj;
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) 
{
    return obj->head == obj->tail;    
}

bool myCircularQueueIsFull(MyCircularQueue* obj)  
{
    // tail + 1 == head;
    return (obj->tail+1) % (obj->k+1) == obj->head;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) 
{
    if(myCircularQueueIsFull(obj))
    {
        return false;
    }

    obj->a[obj->tail] = value;
    obj->tail++;
    (obj->tail) %= (obj->k+1);

    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) 
{
    if(myCircularQueueIsEmpty(obj))
    {
        return false;
    }    

    obj->head++;
    obj->head %= (obj->k+1);

    return true;
}

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

int myCircularQueueRear(MyCircularQueue* obj) 
{
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    
    return obj->a[(obj->tail-1 + obj->k+1) % (obj->k+1)];
    //return obj->tail == 0 ? obj->a[obj->k] : obj->a[obj->tail-1];
}

void myCircularQueueFree(MyCircularQueue* obj) 
{
    free(obj->a);
    //先把数组释放，再把结构体释放
    free(obj);
}

/**
 * Your MyCircularQueue struct will be instantiated and called as such:
 * MyCircularQueue* obj = myCircularQueueCreate(k);
 * bool param_1 = myCircularQueueEnQueue(obj, value);
 
 * bool param_2 = myCircularQueueDeQueue(obj);
 
 * int param_3 = myCircularQueueFront(obj);
 
 * int param_4 = myCircularQueueRear(obj);
 
 * bool param_5 = myCircularQueueIsEmpty(obj);
 
 * bool param_6 = myCircularQueueIsFull(obj);
 
 * myCircularQueueFree(obj);
*/

用栈实现队列

在这里插入图片描述

题解

设计一个为poplist的栈和pushlist的栈
一个栈专门插入数据
一个栈专门删除数据
StackPush(&(obj->pushlist),x)
直接入栈达到了先进的效果
将pushlist中的数据导入poplist中，先进的数据就达到先出的效果了
poplist中有数据直接出
没有数据从pushlist中导数据在出数据
所以两个栈只要有一个栈是非空的就可以出数据
只要有一个栈是非空的，就是非空队列
在这里插入图片描述

代码加解释

typedef struct 
{
   Stack pushlist;
   Stack poplist;
   //后进先出栈实现先进先出队列
} MyQueue;


MyQueue* myQueueCreate() 
{
    MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&(obj->pushlist));
    StackInit(&(obj->poplist));

    return obj;
}

void myQueuePush(MyQueue* obj, int x) 
{
    //直接插入pushlist的队列，队尾入数据也就是栈顶入数据
    StackPush(&(obj->pushlist),x);
}

int myQueuePop(MyQueue* obj) 
{
   int front = myQueuePeek(obj);
   //push pop
   //传过去的应该是obj，指向两个栈的结构体指针
   StackPop(&(obj->poplist));
   return front;
}

int myQueuePeek(MyQueue* obj) 
{
    if(STEmpty(&(obj->poplist)))
    {
        while(!STEmpty(&(obj->pushlist)))
        {
            StackPush(&(obj->poplist),STTop(&(obj->pushlist)));
            StackPop(&(obj->pushlist));
        }
    }
    int ret = STTop(&(obj->poplist));

    return ret;
}

bool myQueueEmpty(MyQueue* obj) 
{
    return STEmpty(&(obj->pushlist)) && STEmpty(&(obj->poplist));    
}

void myQueueFree(MyQueue* obj) 
{
    StackDestroy(&(obj->pushlist));
    StackDestroy(&(obj->poplist));

    free(obj);
}

/**
 * Your MyQueue struct will be instantiated and called as such:
 * MyQueue* obj = myQueueCreate();
 * myQueuePush(obj, x);
 
 * int param_2 = myQueuePop(obj);
 
 * int param_3 = myQueuePeek(obj);
 
 * bool param_4 = myQueueEmpty(obj);
 
 * myQueueFree(obj);
*/
英雄不问出处～
关注
  • 55
    点赞
  • 踩
  • 42
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
LeetCode 栈和队列专题
Amxrjgcs的博客
04-22 395
20. 有效的括号 思路 这种匹配题，尤其是括号匹配，最适合使用的数据结构就是栈，因为天生的只有入栈和出栈操作，对应左右括号的进出，所以我们使用栈来完成括号匹配 首先创建一个栈，来进行匹配操作 遍历字符串，当遇到左括号时，将对应的右括号压入栈中 当匹配到右括号，会取出栈顶元素进行比较，如果相同说明匹配成功；如果不同(括号顺序出现问题)，或者匹配过程中栈为空了(说明已经没有对应的括号与之对应)。那就直接返回false； 最后判断栈是否为空，为空说明全部匹配成功，返回true；否则说明右括号不足，返回fal
LeetCode—栈和队列
weixin_42589774的博客
06-14 196
LeetCode—栈和队列 1、用栈实现队列 T.232 Implement Queue using Stacks (Easy) class MyQueue { public: stack<int> st1,st2; /** Initialize your data structure here. */ MyQueue() { while(!st1.empty()) st1.pop(); while(!st2.empty
leetcode栈和队列专题
kevin的博客
12-31 238
文章目录leetcode栈和队列专题1.栈相关最小栈二叉树遍历二叉树前序遍历二叉树中序遍历二叉树后序遍历逆序栈元素排序栈括号匹配问题验证栈序列2.队列相关设计循环队列3.组合设计栈实现队列队列实现栈 leetcode栈和队列专题 本人大三，目前在准备明年的春招，有问题欢迎及时指出，希望跟大家一起进步 1.栈相关 最小栈 使用双栈来实现最小栈，其中，一个数据栈保存push的所有数据，一个最小栈...
Leetcode分类刷算法之栈和队列专题
weixin_41927235的博客
01-02 183
Leetcode栈和队列 1.最小栈 155.最小栈 class MinStack { private Stack<Integer> data; private Stack<Integer> min; /** initialize your data structure here. */ public MinStack() { ...
基础数据结构leetcode栈和队列专题
清风
12-10 327
栈和队列专题专题 专题 golang力扣leetcode 155.最小栈 golang力扣leetcode 150.逆波兰表达式求值 golang力扣leetcode 394.字符串解码 golang力扣leetcode 94.二叉树的中序遍历 golang力扣leetcode 133.克隆图 golang力扣leetcode 200.岛屿数量 golang力扣leetcode 84.柱状图中最大的矩形 golang力扣leetcode 232. 用栈实现队列 golang力扣leetcode 542.01
leetcode（栈与队列专题）
qq_46517733的博客
11-15 631
栈与队列1.导论2.编程题2.1 232.用栈实现队列2.2 225.用队列实现栈2.3 20.有效的括号2.4 1047.删除字符串中的所有相邻重复项2.5 150. 逆波兰表达式求值2.6 239.滑动窗口最大值2.7 347.前K个高频元素 1.导论 队列是先进先出 栈是先进后出 掌握优先队列（默认小顶堆），比较器的重写 2.编程题 2.1 232.用栈实现队列 请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）： 实现 MyQueue
leetcode专题训练——栈和队列
zyc12321的博客
03-11 131
1、155. 最小栈 设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。 push(x) —— 将元素 x 推入栈中。 pop()—— 删除栈顶的元素。 top()—— 获取栈顶元素。 getMin() —— 检索栈中的最小元素。 解答：两个栈，一个维护最小值 2、150. 逆波兰表达式求值 根据 逆波兰表示法，求表达式的值。 有效的运算符包括+,-,*,/。每个运算对象可以是整数，也可以是另一个逆波兰表达式。 解答：栈的经典应用 ...
【LeetCode刷题】栈与队列专题
D2Ooo的博客
08-13 1610
之前对栈与队列一直停留在表层概念的理解上，不知道怎么用，借刷题的机会来深入理解一下。
LeetCode队列和栈
weixin_42214778的博客
03-08 269
队列和栈队列广度优先搜索（BFS）岛屿数量打开转盘锁完全平方数栈 数据结构与算法是今后学习、求职一直会用到的重要内容，鉴于我大一学的一团糟的惨状，我决定这个暑假根据LeetCode专题的节奏来梳理一些重要的数据结构与算法，巩固一下自己的基础知识，也希望可以给没有好好学习数据结构与算法的小伙伴提个醒，快去刷题！ 队列 队列是一种先进先出（FIFO）的数据结构，插入操作称为入队（enqueue），删除操作称为出队（dequeue）。 为了实现队列，可以使用动态数组和指向队列头部的指针。但是这样的实现会导致队列
leetcode递归专题-leetcode:不定期发布leetcode解题思路和代码
06-30
栈与队列（单调栈） 堆 树状数组、线段树 跳表 哈希链表 水池抽样 milestone 2020年6月9日，800题 √ 2020年6月21日，在这个特别的日子里（不仅仅是Eclipse），完成度50% √。 2020年9月12日，1000题 √ 完成1000题...
acwing和leetcode-Algorithm:acwinglabuladongleetcode
07-07
acwing和leetcode 算法小结 0、排序 快速排序 快速排序 第K个数 归并排序 归并排序 逆序对的数量 1、二分 整数二分 数的范围 小数二分 数的三次方根 2、前缀和 一维前缀和 前缀和数组 二维前缀和 子矩阵的和 3、差分...
BAT霜神Leetcode刷题笔记
08-11
2. **数据结构详解**：包括链表、树、栈、队列、堆、图、字典树等常见数据结构的实现和应用，这些是解决问题的基础，也是面试中的热门话题。 3. **复杂度分析**：讲解时间复杂度和空间复杂度的概念，如何分析算法...
leetCode
03-27
- LeetCode上的问题涵盖数组、链表、栈、队列、树、图、排序、搜索等多种数据结构和算法。 - 挑战分为简单、中等和困难三个等级，适合不同水平的开发者进行学习和实践。 3. **数据结构**： - **数组**：线性数据...
leetcode题库-LeetCode:刷题记录
06-29
queue_stack包为队列和栈专题记录。 linked_list包为链表专题记录。 hash_table包为哈希表专题记录。 data_structure_binary_tree包为二叉树专题记录。 introduction_to_data_structure_binary_search_tree包为二叉...
力扣第233题“数字1的个数”
10年数据\经营分析经验，现任大厂数据分析负责人
07-15 710
本文详细解读了力扣第233题“数字1的个数”，通过使用逐位分析的方法高效地解决了这一问题，并提供了详细的解释和模拟面试问答。希望读者通过本文的学习，能够在力扣刷题的过程中更加得心应手。
Leetcode - 周赛406
最新发布
m0_74859835的博客
07-19 364
Leetcode - 周赛406，主要知识点：dfs记忆化，贪心
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 236
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
leetcode简单题26 N.118 杨辉三角 rust描述
BECOMEviolet的博客
07-16 399
【代码】leetcode简单题26 N.118 杨辉三角 rust描述。
算法面试通关：链表、队列、栈实战+LeetCode解题技巧
本文将聚焦于链表、队列、栈等数据结构，并通过实战题目LeetCode中的几个经典问题进行深入讲解和训练。 首先，链表是基础数据结构之一，例如LeetCode第141题环状链表。解决此问题有两种常见思路：一是使用哈希表...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值