力扣 155 最小栈

最新推荐文章于 2022-08-14 10:34:20 发布
最新推荐文章于 2022-08-14 10:34:20 发布
阅读量251 收藏 1
点赞数
分类专栏： 力扣 简单 文章标签： 最小栈 C python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40519283/article/details/101223933
版权

部分思想及代码转载自：https://blog.csdn.net/alps1992/article/details/41741811

一开始忘了考虑最小栈会被退栈以及还会有进栈的数问题代码报废
每次更新 时间复杂度O(n),过高
效率高的方法，时间复杂度O(1).
我们每次入栈的时候，保存的不再是真正的数字，而是它与当前最小值的差（当前元素没有入栈的时候的最小值）。 这样我们pop和top的时候拿到栈顶元素再加上上一个最小值即可。 另外我们在push和pop的时候去更新min，这样getMin的时候就简单了，直接返回min。
O(1)的办法
这里说下如何O(1)时间内就找到，维护的变量没有变化，但是我们在堆栈内存放的元素需要与Min值产生关联。
例子：
我们进行同样的5次Push操作，压栈顺序为1 2 3 -1 4。

第一次栈存放 默认为0, Min为1. 因为此时最小就是第一个元素. 当前1-Min一定为0.
第二次栈存放2-Min=1, Min<2 所以继续为1.
第三次栈存放3-Min=2, Min<3 所以继续为1.
第四次栈存放-1-Min=-2, Min>-1 所以Min = -1.
第五次栈存放4-Min=5, Min<5 所以继续为-1.
大家看明白没？我们存放的数为x-Min.
这是Push的操作，当我们进行Pop()的时候怎么做呢,进行两次Pop()？

第一次栈顶元素5， 5>0, 弹出，返回 5+Min=4.
第二次栈顶元素-2, -2<0,弹出，返回Min. 并更新Min=Min-(-2).

那Top呢？

假如栈顶元素为5, 5>0 返回5+Min.
假如栈顶元素为-2, -2<0 返回Min.

大家发现没？实际上我们压栈的时候，压入的元素就是X-Min，那么只要压入的元素大于Min，那么存放的都是正数，而当X小于Min的时候，压入的元素(X-Min)就是负数。

所以弹栈的时候：
遇到正数，直接弹出栈顶元素(X-Min)和Min的和(X-Min+Min)就可以了。
遇到负数，说明在压入这个元素的时候Min值有更新，那个时候的Min值被更新为新插入的X. 例如Min=1,插入-1的时候，栈存放-1-Min=-2,而Min更新为新的X值(-1).则弹的时候就直接弹出Min就可以了。那么我们同时也把最小值弹出了，要更新Min,更新为当前Min-(X-下一个Min)此处比较绕，多用例子理解。（这两个是一个思路，最后的M-(X-下一个M)的具体意思：
M下其实是上一个M，这个上下是相对概念，即1，
式子展开就是：
在这里插入图片描述

弹栈时 X-M>0则未更新，直接弹出X
X-M<0,则更新，X<M更新，弹出M且更新，更新值如上

可以加入辅助栈，也可以采用栈的链式存储
代码：
辅助栈：

/***
思路：用两个栈实现。
一个普通栈，一个min栈(普通栈负责数据的入、出，min栈的栈顶永远保存当前元素的最小值)。
第一次入栈时，入到普通栈、min栈中。再次入往普通栈入数据时，当该数据<=min栈栈顶元素时，
也将该数据入到min栈中，否则只入到普通栈中。从普通栈出数据时，该数据==min栈栈顶数据时，
min栈也弹出栈顶元素，否则只弹出普通栈顶元素。总体思想就是min栈用于保存当前数据元素的最小值
**/
typedef struct
{
    int *data1;
    int *data2;
    int top1;//普通
    int top2;//最小

}stack; //两栈

stack *createstack()
{
    stack *obj=(stack*)malloc(sizeof(stack));
    obj->data1=(int *)malloc(sizeof(int)*MAXSIZE);
    obj->top1=-1;
    obj->data2=(int *)malloc(sizeof(int)*MAXSIZE);
    obj->top2=-1;
    return obj;
}
void stackpush(stack *obj,int x)
{
    if(obj->top1==MAXSIZE-1&&obj->top2==MAXSIZE-1)
        return;
    else{
            if(obj->top1==-1&&obj->top2==-1)
            {
                 obj->top1++;//数组下标
        obj->data1[obj->top1]=x;
        obj->top2++;
        obj->data2[obj->top2]=x;
            }
            else if(x<=obj->data2[obj->top2])
            {
                 obj->top1++;
        obj->data1[obj->top1]=x;
        obj->top2++;
        obj->data2[obj->top2]=x;
            }
            else{
                obj->top1++;
        obj->data1[obj->top1]=x;
            }

    }
}
void stackpop(stack *obj)
{
    if(obj->top1==-1&&obj->top2==-1)
    {
        return;
    }
    else if(obj->data1[obj->top1]==obj->data2[obj->top2])
    {
        obj->top1--;
        obj->top2--;
    }
    else{
        obj->top1--;
    }
}
int stacktop(stack *obj)
{
    return obj->data1[obj->top1];
}
int stackgetmin(stack *obj)
{
    return obj->data2[obj->top2];
}

int main()
{
  stack *obj=createstack();
  stackpush(obj,8);
  stackpush(obj,0);
  stackpush(obj,9);
  stackpush(obj,-5);
  stackpop(obj);
  int a=stackgetmin(obj);
  printf("%d\n",a);


}

链栈：

#include <iostream>
#include <stdio.h>
#include <tchar.h>
#include <iostream>
using namespace std;
class MinStack {
public:

    struct StackNode{
        int num;
        StackNode *next;
    };
    typedef StackNode* stack;
    stack s;
    MinStack(){
        s = (stack)malloc(sizeof(struct StackNode));
        s->next = NULL;
    }

    int min;

    void push(int x) {
        if (s->next == NULL) {
            stack node = (stack)malloc(sizeof(struct StackNode));
            node->num = x;
            node->next = s->next;
            s->next = node;
            min = x;
        }else{
            stack node = (stack)malloc(sizeof(struct StackNode));
            node->num = x;
            node->next = s->next;
            s->next = node;
            if (x < min) {
                min = x;
            }
        }
    }

    void pop() {
        if (s->next == NULL) {
            return;
        }else{
            stack temp = s->next;
            if (min == s->next->num && s->next->next != NULL) {

                s->next = s->next->next;
                free(temp);
                min = s->next->num;
                for (stack loop = s->next; loop != NULL; loop = loop->next) {
                    if (min > loop->num) {
                        min = loop->num;
                    }
                }
            }else{

                s->next = s->next->next;
                free(temp);
            }

        }
    }

    int top() {
        if (s->next == NULL) {
            return NULL;
        }
        return s->next->num;
    }

    int getMin() {
        if (s->next == NULL) {
            return NULL;
        }
        return min;
    }
};

int main(int argc, const char * argv[]) {
    MinStack MinS;
    MinS.push(-1);
    MinS.push(0);
    MinS.push(2);
    MinS.push(-2);
    printf("%d\n",MinS.top());
    MinS.pop();
    MinS.pop();
    MinS.pop();
    printf("%d\n",MinS.getMin());
    return 0;

}

最普通方法：

#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 100

//普通法 时间复杂度O(n)
typedef struct {
  int *data;
  int top;

}minstack;
minstack *minstackinit()
{
    minstack *obj=(minstack *)malloc(sizeof(minstack));
    obj->data=(int *)malloc(sizeof(int)*MAXSIZE);
    obj->top=-1;
    return obj;
}
void minstackpush(minstack *obj,int x)
{
    if(obj->top==MAXSIZE-1)
        return;
    else{
        obj->top++;
        obj->data[obj->top]=x;
    }
}
void minstackpop(minstack *obj)
{
    if(obj->top==-1)
        return;
    else{
        obj->top--;
    }
}
int minstackTop(minstack *obj)
{
    if(obj->top==-1)
        return 0;
    return obj->data[obj->top];
}
int minstackgetmin(minstack *obj)
{

    if(obj->top==-1)
        return 0;
    if(obj->top==0)
        return obj->data[obj->top];
    int min=obj->data[0];
    for(int i=0;i<obj->top;i++)
    {
        if(obj->data[i]<min)
            min=obj->data[i];

    }
    return min;
}
int main()
{
    minstack *obj=minstackinit();

    minstackpush(obj,8);
    minstackpush(obj,21);
    minstackpush(obj,6);
    minstackpop(obj);
    printf("%d\n",minstackTop(obj));
    int a=minstackgetmin(obj);
    printf("%d\n",a);
}

差值法：

class MinStack:

    def __init__(self):
        """
        initialize your data structure here.
        """
        self.min = float('inf')
        self.stack = []

    def push(self, x: int) -> None:
        self.stack.append(x - self.min)
        if x < self.min:
            self.min = x

    def pop(self) -> None:
        if not self.stack:
            return
        tmp = self.stack.pop()
        if tmp < 0:
            self.min -= tmp

    def top(self) -> int:
        if not self.stack:
            return
        tmp = self.stack[-1]
        if tmp < 0:
            return self.min
        else:
            return self.min + tmp

    def getMin(self) -> int:
        return self.min

做题确实有助于对知识的理解，栈不管是什么形式构造只要保持其基本特点即可，之前有点拘泥于课本上的形式了
部分代码及思路链接：
https://blog.csdn.net/alps1992/article/details/41741811
https://github.com/azl397985856/leetcode/blob/master/problems/155.min-stack.md

oomoomoooq
关注
专栏目录
最小栈——力扣155
qq_42251157的博客
07-09 478
空间复杂度：O(n)，其中 n 为总操作数。最坏情况下，我们会连续插入 n 个元素，此时两个栈占用的空间为 O(n)。时间复杂度为O(1)。因为栈的插入、删除与读取操作都是 O(1)，定义的每个操作最多调用栈操作两次。这些函数中只有求最小值函数需要借助辅助栈。
leetcode:155.最小栈
uncle_ll的博客
06-14 244
来源：力扣（LeetCode）链接: https://leetcode.cn/problems/min-stack/设计一个支持 ， ， 操作，并能在常数时间内检索到最小元素的栈。实现 类:示例 1: 提示：对于这类题目一般是使用辅助栈，类似的题目有用两个栈实现队列，只用队列实现栈，顺序倒一遍，都是需要使用辅助栈或者队列；python实现 c++实现 复杂度分析......
最小栈实现
JustWith的博客
10-11 363
最小栈实现 设计一个支持 push，pop，top 操作，并能在常数时间内检索到最小元素的栈。 push(x) – 将元素 x 推入栈中。 pop() – 删除栈顶的元素。 top() – 获取栈顶元素。 getMin() – 检索栈中的最小元素。 public class MinStack { private Stack&lt;Integer&gt; s; private Li...
力扣最小栈
dayday学习的博客
03-01 420
最小栈 设计一个支持 push，pop，top 操作，并能在常数时间内检索到最小元素的栈。 push(x) – 将元素 x 推入栈中。 pop() – 删除栈顶的元素。 top() – 获取栈顶元素。 getMin() – 检索栈中的最小元素。 示例: MinStack minStack = new MinStack(); minStack.push(-2); minStack.push(0); ...
力扣：最小栈
K_CRACKING的博客
07-27 245
设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。 push(x) —— 将元素 x 推入栈中。 pop() —— 删除栈顶的元素。 top() —— 获取栈顶元素。 getMin() —— 检索栈中的最小元素。 示例： 输入： ["MinStack","push","push","push","getMin","pop","top","getMin"] [[],[-2],[0],[-3],[],[],[],[]] 输出： [null,null,null,null,-3
155.最小栈-力扣（LeetCode）
qq_53505979的博客
09-05 645
目录55.最小栈-力扣（LeetCode）正确题解优化题解1优化题解2 55.最小栈-力扣（LeetCode） ????155.最小栈-力扣（LeetCode） 题目描述：设计push、pop、top、getMin，函数，并且可以在时间复杂度为O(1)的情况下找出最小值 错误的思路：给定一个变量，来记录最小值，这种想法是错误的，我们应该要更全面的考虑问题。 当我们入栈{6，5，4，3，2，1}时，每次记录最小值的变量随着每次入栈而改变，当数据全部入栈，记录最小值的变量就为1，如果在不删除数据的情况下，可以
LeetCode力扣 —— 最小栈
weixin_43580746的博客
04-06 221
最小栈 - 就是在栈中添加一个求栈中最小元素的方法 文章目录问题描述示例代码演示代码1方法2 问题描述 设计一个栈，其中包括 push()：给栈中添加元素 pop()：获取栈顶元素（顺便将栈顶元素删除） top()：读取栈顶元素（不删除元素） getMin()：读取当前栈中的最小元素 示例 代码 结果 MinStack minStack = new MinStack() 无...
LeetCode155. 最小栈(java)
inferno_devil的博客
03-29 406
题目： 设计一个支持 push，pop，top 操作，并能在常数时间内检索到最小元素的栈。 push(x) – 将元素 x 推入栈中。 pop() – 删除栈顶的元素。 top() – 获取栈顶元素。 getMin() – 检索栈中的最小元素。 示例： 代码： 解法一 class MinStack { private Stack<Integer> stackData; ...
Leetcode | 155. 最小栈(java实现)
Cherils的博客
05-12 389
Leetcode【栈】| 155. 最小栈题目解题题目分析两个栈实现 题目 设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。 　push(x) —— 将元素 x 推入栈中。 　pop() —— 删除栈顶的元素。 　top() —— 获取栈顶元素。 　getMin() —— 检索栈中的最小元素。 示例: 输入： 　[“MinStack”,“push”,“push”,“push”,“getMin”,“pop”,“top”,“getMin”] 　[　　[],　　　[-2],
LeetCode—155.最小栈(Min Stack)——分析及代码（C++）
江南土豆的博客
11-14 658
LeetCode—155.最小栈[Min Stack]——分析及代码[C++] 一、题目 二、分析及代码 1. 辅助栈 （1）思路 （2）代码 （3）结果 2. 辅助map （1）思路 （2）代码 （3）结果 三、其他 一、题目 设计一个支持 push，pop，top 操作，并能在常数时间内检索到最小元素的栈。 push(x) – 将元素 x 推入栈中。 pop() – 删除栈顶的元素。 top() – 获取栈顶元素。 getMin() – 检索栈中的最小元素。 示例: MinStack minStac
力扣155.最小栈
chukun4948的博客
01-30 210
设计一个支持 push，pop，top 操作，并能在常数时间内检索到最小元素的栈。 push(x)-- 将元素 x 推入栈中。 pop()-- 删除栈顶的元素。 top()-- 获取栈顶元素。 getMin() -- 检索栈中的最小元素。 示例: MinSta...
【力扣】155. 最小栈
漆黑梦工厂
01-20 213
题目：设计一个支持 push，pop，top 操作，并能在常数时间内检索到最小元素的栈。 push(x) -- 将元素 x 推入栈中。 pop() -- 删除栈顶的元素。 top() -- 获取栈顶元素。 getMin() -- 检索栈中的最小元素。 示例: MinStack minStack = new MinStack(); minStack.push(-2); minStack.push(...
力扣打卡之最小栈
young_man2的博客
08-14 184
力扣打卡之最小栈
力扣-155-最小栈
小吕的博客
05-12 254
1、 2、 class MinStack { public: /** initialize your data structure here. */ MinStack() { } stack<int> minstack; stack<int>data; void push(int x) { data.push(x); if(minstack.empty()||x<=min
力扣-最小栈（Java实现）
世纪末的架构师的博客
01-29 998
力扣题目最小栈的解题思路以及总结与收获
力扣之155. 最小栈
zhaoge's blog
05-12 186
设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。 push(x) —— 将元素 x 推入栈中。 pop() —— 删除栈顶的元素。 top() —— 获取栈顶元素。 getMin() —— 检索栈中的最小元素。 示例: 输入： [“MinStack”,“push”,“push”,“push”,“getMin”,“pop”,“top”,“getMin”] [[],[-2],[0],[-3],[],[],[],[]] 输出： [null,null,null,null,
力扣155题，最小栈
sxycylq的博客
07-26 143
力扣155题，最小栈，堆栈，辅助栈
【数据结构 - 栈】：力扣题:实现一个最小栈
m0_64397675的博客
06-18 258
实现一个最小栈
力扣之最小栈——155
weixin_44617944的博客
03-22 169
问题 解答 辅助栈 min_stack作为储存最小元素的辅助栈使getMin()函数时间复杂度达到O(1) class MinStack: def __init__(self): self.stack = [] self.min_stack = [] def push(self, x: int) -> None: self.s...
力扣官网编程原题解析与求职刷题指南
资源摘要信息:"Leet Code_力扣原题_leetcode官网_" LeetCode是一个专注于为软件工程师提供编程题目和解决方案的在线平台，它为求职者和专业程序员提供了一个实际操作和练习的场所。通过解决LeetCode上提供的各种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值