LeetCode 155. 最小栈

LeetCode 155. 最小栈

今天写题发现了一个很精妙的解法,在这里记录一下

首先看下题目描述：

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

push(x) —— 将元素 x 推入栈中。
pop() —— 删除栈顶的元素。
top() —— 获取栈顶元素。
getMin() —— 检索栈中的最小元素。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/min-stack

示例：

输入：
["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.

思路：
这道题的其实就是写一个类出来，其中三个类方法在c++ 的stack中都有，只有getMin()这个函数需要特别对待，由于getMin()需要在常量时间内检索，也就是说不能通过遍历去获取，那么就需要在插入和删除元素的时候把最小值获取了，然后调用getMin()直接返回最小值。

（1）下面是我的c++实现代码：

这个方法在插入和获取值的时候的比较优秀,复杂度是O(1)，但是一旦删除了最小值，需要遍历两边堆栈，复杂度是O(n);

class MinStack {
public:
	MinStack() {
	}
	stack<int> stack1;	//主栈
	stack<int> stack2;	//辅助栈
	int minValue = INT_MAX;	//最小值

	void push(int x) {
		stack1.push(x);
		if (minValue > x)	//插入时比较大小
			minValue = x;
	}

	void pop() {
		if (stack1.top() == minValue) {	//如果出栈的元素是最小值，那么需要重新获取最小值
			stack1.pop();
			minValue = INT_MAX;
			while (!stack1.empty()) {		//由于堆栈不能遍历，只能全部取出，判断最小值
				if (minValue > stack1.top())
					minValue = stack1.top();
				stack2.push(stack1.top());
				stack1.pop();
			}
			while (!stack2.empty()) {	//取出之后放回去
				stack1.push(stack2.top());
				stack2.pop();
			}
		}
		else {
			stack1.pop();
		}
	}

	int top() {
		return stack1.top();
	}

	int getMin() {
		return minValue;
	}
};

（2）官方答案

我们可以换种思路：每插入一个数的时候，辅助栈都会比较 该数与当前最小值，如果把两者的最小值插入到辅助栈中,插入和删除 的时间复杂度是O(2), 获取值的是O(1)。
例如：
x_stack = {1,0,2,3,-1}
min_stack ={1,0,0,0,-1}
代码如下：

class MinStack {
    stack<int> ;
    stack<int> min_stack;
public:
    MinStack() {
        min_stack.push(INT_MAX);
    }
    
    void push(int x) {
        x_stack.push(x);
        min_stack.push(min(min_stack.top(), x)); // 插入对应主栈元素的最小值（栈底到该元素的最小值）
    }
    
    void pop() {
        x_stack.pop();
        min_stack.pop();
    }
    
    int top() {
        return x_stack.top();
    }
    
    int getMin() {
        return min_stack.top();
    }
};

//作者：LeetCode-Solution
//链接：https://leetcode-cn.com/problems/min-stack/solution/zui-xiao-zhan-by-leetcode-solution/
//来源：力扣（LeetCode）

（3）大神的答案

这是对方法二的一种优化，只需要一个栈和一个最小值int。
（1）每进栈一个数都需要对其进行判断，如果该数大于最小值直接插入，如果小于最小值，先插入最小值，然后再插入该数，并将该数赋值给最小值
（2）每退栈一个数，判断是否等于最小值，如果等于最小值，先删除栈顶，然后将新的栈顶赋值给最小值，如果栈不为空，再删除一次；（删除两次，是对应着（1）中的插入两次）
插入或删除 时间复杂度是O(1)或O(2),获取是O(1)
下面是实现的C++代码：

class MinStack {
public:
	MinStack() {
	}
	stack<int > stack1;
	int min;

	void push(int x) {
		if (stack1.empty()) {
			min = x;
		}
		else if (min >= x) {
			stack1.push(min);	//这一步很关键，保证了删除最小值后，下一个还是剩下元素的最小值。
			min = x;
		}
		stack1.push(x);
	}

	void pop() {
		if (stack1.size() != 1 &&stack1.top() == min) {
			stack1.pop();	//如果出栈最小值，直接删除
			min = stack1.top();	//获取最小值
		}
		stack1.pop();
	}

	int top() {
		return stack1.top();
	}

	int getMin() {
		return min;
	}
};

(4)最后

就写到这里了，如有不够严谨之处，请大家指出来。