leadcode的Hot100系列--155. 最小栈

栈:先入后出,后入先出

像电梯一样,先进入电梯的,走到电梯最深处,后进入电梯的,站在电梯门口,
所以电梯打开的时候,后进入的会先走出来,先进入的会后走出来。

  • push,对应入电梯,把数据往里面压
  • pop, 对应出电梯,把数据往外拿
  • 栈顶,对应电梯门口
  • 栈底,对应电梯最深处

这里使用链表实现栈。
先创建一个MinStack头,
入栈:直接把结构体挂在MinStack头后面,
出栈:直接拿出MinStack头后面的结构体。
取最小值:对链表进行一次遍历,返回最小值。

typedef struct minstack{
    struct minstack *pNext;
    int val;
} MinStack;

/** initialize your data structure here. */

MinStack* minStackCreate() {             // 创建一个 minStack 头
    MinStack *pstTemp = NULL;
    pstTemp = (MinStack *)calloc(1, sizeof(MinStack));
    if (NULL == pstTemp)
        return NULL;
    pstTemp->pNext = NULL;
    return pstTemp;
}

void minStackPush(MinStack* obj, int x) {    // 入栈
    MinStack *pstTemp = NULL;
    if (NULL == obj)
        return;
    pstTemp = (MinStack *)calloc(1, sizeof(MinStack));
    if (NULL == pstTemp)
        return;
    pstTemp->val = x;
    pstTemp->pNext = obj->pNext;
    obj->pNext = pstTemp;
    return;
}

void minStackPop(MinStack* obj) {      // 出栈
    MinStack *pstTemp = NULL;
    if ((NULL == obj) || (NULL == obj->pNext))
        return;
    pstTemp = obj->pNext;
    obj->pNext = pstTemp->pNext;
    free(pstTemp);
    pstTemp = NULL;
    return;
}

int minStackTop(MinStack* obj) {
    MinStack *pstTemp = NULL;
    if ((NULL == obj) || (NULL == obj->pNext))
        return;
    pstTemp = obj->pNext;
    return pstTemp->val;
}

int minStackGetMin(MinStack* obj) {
    MinStack *pstTemp = NULL;
    int iMin = 0;
    if ((NULL == obj) || (NULL == obj->pNext)) // 这里如果确实是一个空链表的话,返回0的话好像也不太对
        return iMin;
    else
    {
        pstTemp = obj->pNext;
        iMin = pstTemp->val;   // 这里需要使用栈里面值初始化一下iMin,万一栈里面所有的值都大于0,就会返回最小值为0,就错了
        pstTemp = pstTemp->pNext;
    }
    while(NULL != pstTemp)
    {
        if (pstTemp->val < iMin)
            iMin = pstTemp->val;
        pstTemp = pstTemp->pNext;
    }
    return iMin;
}

void minStackFree(MinStack* obj) {
    MinStack *pstNow = NULL;
    MinStack *pstNext = NULL;
    if ((NULL == obj) || (NULL == obj->pNext))
        return;
    pstNow = obj->pNext;
    while(NULL != pstNow)
    {
        pstNext = pstNow->pNext;
        free(pstNow);
        pstNow = NULL;
        pstNow = pstNext;
    }
    return;
}

/**
 * Your MinStack struct will be instantiated and called as such:
 * MinStack* obj = minStackCreate();
 * minStackPush(obj, x);

 * minStackPop(obj);

 * int param_3 = minStackTop(obj);

 * int param_4 = minStackGetMin(obj);

 * minStackFree(obj);
*/

原文地址:https://www.cnblogs.com/payapa/p/11123743.html

时间: 2024-07-31 15:22:17

leadcode的Hot100系列--155. 最小栈的相关文章

155. 最小栈

设计一个支持 push,pop,top 操作,并能在常数时间内检索到最小元素的栈. push(x) -- 将元素 x 推入栈中. pop() -- 删除栈顶的元素. top() -- 获取栈顶元素. getMin() -- 检索栈中的最小元素. 示例: MinStack minStack = new MinStack(); minStack.push(-2); minStack.push(0); minStack.push(-3); minStack.getMin(); --> 返回 -3. m

leetcode 155. 最小栈(c++)

设计一个支持 push,pop,top 操作,并能在常数时间内检索到最小元素的栈. push(x) -- 将元素 x 推入栈中.pop() -- 删除栈顶的元素.top() -- 获取栈顶元素.getMin() -- 检索栈中的最小元素.示例: MinStack minStack = new MinStack();minStack.push(-2);minStack.push(0);minStack.push(-3);minStack.getMin(); --> 返回 -3.minStack.p

leadcode的Hot100系列--136. 只出现一次的数字

因为之前刚写了461号题目,这个题目与那个很相似, 461号题目用异或来算两个不一样的部分, 那这个题目需要排除一样的部分,并找到不一样的部分. 那么可以再利用一下异或的特性: 1.相同为0,所以,a ^ a = 0. 2.不同为0,所以,0 ^ b = b. 所以,假设数组里面的数分别就是 a,a,b, ---> a ^ a ^ b = b,那么b就是要找的那个不一样的数字. (异或的最终结果与异或的顺序无关,即 a ^ b ^ c = a ^ c ^ b = b ^ c ^ a ). 附上代

leadcode的Hot100系列--461. 汉明距离

求两个数的二进制位不同的位置,最先想到的就是异或操作, 异或:按位运算,相同为0,不同为1. 比如: a = 6 对应的二进制表示为: 0 0 1 1 1 ? b = 9 对应的二进制表示为: 0 1 0 0 1 则 a ^ b = 14 对应的二进制表示为: 0 1 1 1 0 所以,只要算出异或之后的数的二进制表示方法里面1的个数. 比如,对于上面的异或之后为14,14的二进制里面1的个数为3,那么汉明距离就是3. 想知道是否有1,最快的当然还是位与操作, 与:按位运算,相当于乘法,0与0是

leadcode的Hot100系列--617. 合并二叉树

合并,就是两个树的结构交集部分,数据相加,否则,取非空部分. 所以,这里相当于是对两棵树同时遍历: 如果两棵树节点都不为空,则数据相加, 否则,直接指针把不为空的节点复制过来. 注:这里没有申请内存,而直接对原有的树进行改造,这样可以节省申请内存的时间,且节省一些内存. struct TreeNode* mergeTrees(struct TreeNode* t1, struct TreeNode* t2){ struct TreeNode *pTemp = NULL; if ((NULL ==

leadcode的Hot100系列--226. 翻转二叉树

这玩意儿基本上还是遍历的那一套, 这里使用先序遍历的方式,直接对左右子树进行对调即可. (虽然看题目的时候,感觉都一样,但真正写出来之后,印象还是深刻了很多) struct TreeNode* invertTree(struct TreeNode* root){ struct TreeNode *pTemp = NULL; if (NULL == root) return NULL; pTemp = root->left; root->left = root->right; root-&

leadcode的Hot100系列--62. 不同路径--简单的动态规划

题目比较清晰,简单来说就是: A B C D E F G H I J K L 只能往右或者往下,从A到L,能有几种走法. 这里使用动态规划的方法来做一下. 动态规划最重要的就是动态方程,这里简单说下这个动态方程怎么做出来的吧. 记 f(B) 为 A到B总共可以有的走法. 想知道f(L),那其实只要知道f(H)和f(K)就可以了. 因为从A到H之后,再想到L就只有一种方法,AK同理,所以 f(L) = f(H) + f(K). 那f(H)呢,就等于 f(D)+f(G),这里就很容易得到他的动态方程

leetcode——155. 最小栈

class MinStack(object): def __init__(self): """ initialize your data structure here. """ self._elem=[] def push(self, x): """ :type x: int :rtype: None """ self._elem.append(x) def pop(self): &qu

最小栈

思想分析: 实现方案: class MinStack { public: MinStack() {} void push(int x) { if (StackNum.empty()) { StackNum.push(x); StackMin.push(x); } else { if (x <= StackMin.top()) StackMin.push(x); StackNum.push(x); } } void pop() { if (StackMin.top() == StackNum.to