力扣 最小栈

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

实现 MinStack 类:

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

示例 1:

输入：
["MinStack","push","push","push","getMin","pop","top","getMin"]
[[],[-2],[0],[-3],[],[],[],[]]

输出：
[null,null,null,null,-3,null,0,-2]

解释：
MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.getMin();   --> 返回 -3.
minStack.pop();
minStack.top();      --> 返回 0.
minStack.getMin();   --> 返回 -2.

思路：

前几个对栈进行初始化、入栈、出栈、取栈顶元素都是我们非常熟悉的，但最后一个取栈中最小元素，如果题目没有限制为常数阶，那我们就可以定义一个min,来记录栈中元素的最小值，不过此方法需将栈中元素逐一与min进行比较，时间复杂度为线性阶，不符合题意，那我们就来定义一个辅助栈，只放入当前栈的最小值，此时辅助栈的栈顶元素就为我们栈中的最小值。

因此我们定义的栈中就有四个元素：

#define max 10000
typedef struct {
    int data[max];/*栈的数据域*/
    int top;
    int mindata[max];/*辅助站的数据域*/
    int mintop;
} MinStack;

其他就正常初始化，出栈入栈，取栈顶。

需要注意的是：在进栈的过程中，如果辅助栈目前为空，val也要进辅助站，如果辅助栈不为空，那么入栈的元素要与辅助栈栈顶元素相比，如果输入的元素比栈顶元素还要小，说明当前栈中更小的为此元素，需要压入到辅助栈中。

在出栈操作中，如果当前栈中元素值与辅助站中元素值相同，说明都是最小值，都要pop出来，所以辅助栈的top值也要mintop--。其余与我们普通栈的基本操作大致相同。

需要注意的是：我们平常习惯将top值赋值为-1，但如果改为-1，它的测试用例不能全部通过。例如：

#define max 10000
typedef struct {
    int data[max];
    int top;
    int mindata[max];
    int mintop;
} MinStack;
MinStack* minStackCreate() {
    MinStack *s;
    s=(MinStack*)malloc(sizeof(MinStack));
    s->top=-1;
    s->mintop=-1;
    return s;
}
void minStackPush(MinStack* obj, int val) {
    if(obj->top==max){
        return ;
    }
    else{
        obj->top++;
        obj->data[obj->top]=val;
        if(obj->mintop==-1||val<obj->mindata[obj->mintop]){
            obj->mintop++;
            obj->mindata[obj->mintop]=val;
        }
    }
}
void minStackPop(MinStack* obj) {
    if(obj->top==-1){
        return ;
    }
    else{
        if(obj->data[obj->top]==obj->mindata[obj->mintop]){
            obj->mintop--;
        }
        obj->top--;
    }
}
int minStackTop(MinStack* obj) {
    if(obj->top==-1){
        return 0;
    }
    else{
        return obj->data[obj->top];
    }
}
int minStackGetMin(MinStack* obj) {
    if(obj->mintop==-1){
        return 0;
    }
    else{
        return obj->mindata[obj->mintop];
    }
}
void minStackFree(MinStack* obj) {
    free(obj);
}

将top值改为0之后：

#define max 10000
typedef struct {
    int data[max];
    int top;
    int mindata[max];
    int mintop;
} MinStack;
MinStack* minStackCreate() {
    MinStack *s;
    s=(MinStack*)malloc(sizeof(MinStack));
    s->top=0;
    s->mintop=0;
    return s;
}
void minStackPush(MinStack* obj, int val) {
        obj->data[obj->top]=val;
        obj->top++;
        if(obj->mintop==0||val<=obj->mindata[obj->mintop-1]){
            obj->mindata[obj->mintop]=val;
            obj->mintop++;
        }
}
void minStackPop(MinStack* obj) {
        if(obj->data[obj->top-1]==obj->mindata[obj->mintop-1]){
            obj->mintop--;
        }
        obj->top--;
    }
int minStackTop(MinStack* obj) {
        return obj->data[obj->top-1];
}
int minStackGetMin(MinStack* obj) {
        return obj->mindata[obj->mintop-1];
    }
void minStackFree(MinStack* obj) {
    free(obj);
}

 就可以全部运行通过。当我们的top值为0时，我们就把obj->data[obj->top]=val;然后在对obj->top++（因为数组下标刚好从0开始),返回栈顶时也要在top基础上减一,有一点区别。