LeetCode_155. 最小栈_C

设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。

实现 MinStack 类:
MinStack() 初始化堆栈对象。
void push(int val) 将元素val推入堆栈。
void pop() 删除堆栈顶部的元素。
int top() 获取堆栈顶部的元素。
int getMin() 获取堆栈中的最小元素。

两个方法：
方法一：使用辅助栈，存入最小值，当getmin时，去辅助栈；当pop时，如果两个栈顶元素相等，两个栈都出栈
方法二：每次入栈都记录dat和min；不需要辅助栈

https://leetcode.cn/problems/min-stack/

solution 2

/**
    因为要能在常数时间内检索到最小元素的栈，如果直接简单用栈，getmin时需要遍历一遍，这可不行
    方法一：使用辅助栈，存入最小值，当getmin时，去辅助栈；当pop时，如果两个栈顶元素相等，两个栈都出栈
    方法二：每次入栈都记录dat和min；不需要辅助栈

*/

//方法二
struct stack{//单栈同时存储 最小值 + 数据值 一起成套的入栈中
    int dat;
    int min;
};
typedef struct {//声明结构体类型
//typedef为C语言的关键字，作用是为一种数据类型定义一个新名字。
//这里的数据类型包括内部数据类型（int,char等）和自定义的数据类型（struct等）。
//typedef struct是定义一个标识符及关键字的别名，无具体含义。它是语言编译过程的一部分，为了使用结构体方便。
    
    //正常 stack
    struct stack stackDat[10000];
    int stackTop;
} MinStack;

MinStack* minStackCreate() {//初始化堆栈元素 
    MinStack* newStack = (MinStack*)malloc(sizeof(MinStack));//动态规划申请一个栈，叫newStack
    newStack->stackTop = 0;
    return newStack;
}
// 函数传入MinStack* obj的是头指针，实际的值是指向Next的
void minStackPush(MinStack* obj, int val) {//push 将元素val推入堆栈
    //先压入数据栈
    obj->stackDat[obj->stackTop].dat=val;

    //判断当前最小值，压入最小值
    if(!obj->stackTop||val <= obj -> stackDat[obj->stackTop-1].min){
        obj->stackDat[obj->stackTop].min = val;
    }else{
        obj->stackDat[obj->stackTop].min = obj->stackDat[obj->stackTop-1].min;
    }
    obj->stackTop++;
}

void minStackPop(MinStack* obj) {//pop删除堆栈栈顶元素
    obj->stackTop--;
}

int minStackTop(MinStack* obj) {//top获取堆栈顶部元素
    return obj->stackDat[obj->stackTop-1].dat;
}

int minStackGetMin(MinStack* obj) {//getmin获取堆栈中的最小元素
    return obj->stackDat[obj->stackTop-1].min;
}

void minStackFree(MinStack* obj) {//free释放
    free(obj);
}

/**
 * Your MinStack struct will be instantiated and called as such:
 * MinStack* obj = minStackCreate();
 * minStackPush(obj, val);
 
 * minStackPop(obj);
 
 * int param_3 = minStackTop(obj);
 
 * int param_4 = minStackGetMin(obj);
 
 * minStackFree(obj);
*/

solution 1

//方法一
//单调栈 单调递减
typedef struct{
    //正常 stack
    int stack[10000];
    int stackTop;

    //辅助 stack
    int minStack[10000];
    int minStackTop;
}MinStack;

MinStack* minStackCreate(){
    MinStack* newStack = (MinStack*)malloc(sizeof(MinStack));
    newStack->stackTop = 0;
    newStack->minStackTop = 0;
    return newStack;
}

void minStackPush(MinStack* obj,int val){
    //先压入数据栈
    obj->stack[obj->stackTop++]=val;

    //当前值 小于等于 辅助栈顶值
    if(!obj->minStackTop||val <= obj->minStack[obj->minStackTop-1]){
        obj->minStack[obj->minStackTop++]=val;
        //先操作再自增
    }

}
void minStackPop(MinStack* obj){
    if(obj->minStack[obj->minStackTop-1]==obj->stack[obj->stackTop-1]){
        obj->minStackTop--;
    }
    obj->stackTop--;
}

int minStackTop(MinStack* obj){
    return obj->stack[obj->stackTop-1];
}

int minStackGetMin(MinStack* obj){
    return obj->minStack[obj->minStackTop-1];
}

void minStackFree(MinStack* obj){
    free(obj);
}

/**
 * Your MinStack struct will be instantiated and called as such:
 * MinStack* obj = minStackCreate();
 * minStackPush(obj, val);
 
 * minStackPop(obj);
 
 * int param_3 = minStackTop(obj);
 
 * int param_4 = minStackGetMin(obj);
 
 * minStackFree(obj);
*/