55.最小栈-力扣(LeetCode)
题目描述:设计push、pop、top、getMin,函数,并且可以在时间复杂度为O(1)的情况下找出最小值
错误的思路:给定一个变量,来记录最小值,这种想法是错误的,我们应该要更全面的考虑问题。
当我们入栈{6,5,4,3,2,1}时,每次记录最小值的变量随着每次入栈而改变,当数据全部入栈,记录最小值的变量就为1,如果在不删除数据的情况下,可以以O(1)的时间复杂度找到最小值,但是如果删除出来一个栈顶的元素,则栈中的最小值也发生了改变,与记录最小值的变量不匹配。
正确题解
通过上面的错误思路,我们可以加以改进。
在每一次元素入栈时,记录当前栈中的最小值,存放在另一个栈中。
例如:{6,5,4,3,2,1}
当6入栈时,当前栈中的元素最小值为6;
当5入栈时,当前栈中的元素最小值为5;
当4入栈时,当前栈中的元素最小值为4;
当3入栈时,当前栈中的元素最小值为3;
当2入栈时,当前栈中的元素最小值为2;
当1入栈时,当前栈中的元素最小值为1;
把每次入栈时的最小元素存放在一个栈(min_stack)中来保存。
当删除栈顶的元素时,min_stack也随之删除栈顶元素,保证了栈中元素的最小值与min_stack对应,找栈中最小值时直接在min_stack中的栈顶拿。时间复杂度为O(1),这种做法叫以空间换时间。
代码:
class MinStack {
public:
/** initialize your data structure here. */
MinStack() {}
void push(int val) {
st.push(val);
if(min_stack.empty()||val<=min_stack.top())
min_stack.push(val);
else
{
min_stack.push(min_stack.top());
}
}
void pop() {
st.pop();
min_stack.pop();
}
int top() {
return st.top();
}
int getMin() {
return min_stack.top();
}
private:
stack<int> st;
stack<int> min_stack;
};
优化题解1
在上面的方法中,存在着空间浪费。
例如:{5,3,2,4,6,1}
在min_stack中也存放{5,3,2,2,2,1},在入栈4,6时,也要在min_stack中存放2,形成了一定程度的空间浪费。
有什么好解决的方法吗?如果呢避免就好了。🧐
当入栈的元素比min_stack栈顶的元素大时,min_stack则不需要保存这时栈中的最小值。
只有入栈的元素比min_stack栈顶的元素小或者等于时,才需要保存这时栈中的最小值。
例如:{5,3,2,4,6,1}
1:5入栈时,当前最小值为5,min_stac保存5,这时min_stack中只要5:{5}
2:3入栈时,当前最小值为3,min_stac保存3,这时min_stack中只要5:{5,3}
3:2入栈时,当前最小值为2,min_stac保存2,这时min_stack中只要5:{5,3,2}
4:4入栈时,当前最小值为2,不需要保存这时的最小值,这时min_stack中只要5:{5,3,2}
5:6入栈时,当前最小值为2,不需要保存这时的最小值,这时min_stack中只要5:{5,3,2}
6:1入栈时,当前最小值为1,min_stac保存1,这时min_stack中只要5:{5,3,2,1}
在删除栈顶元素时,当栈顶元素与min_stack栈顶元素相同时,则min_stack栈顶元素也删除。不同时,min_stack栈顶元素不需要删除。
代码:
class MinStack {
public:
/** initialize your data structure here. */
MinStack() {}
void push(int val) {
st.push(val);
if(min_stack.empty()||val<=min_stack.top())
min_stack.push(val);
}
void pop() {
if(st.top()==min_stack.top())
{
min_stack.pop();
}
st.pop();
}
int top() {
return st.top();
}
int getMin() {
return min_stack.top();
}
private:
stack<int> st;
stack<int> min_stack;
};
优化题解2
在优化题解1中还会存在浪费空间。
例如:{5,3,2,2,2,6,4,1,1,1}
用优化题解1中的方法:min_stack:{5,3,2,2,2,1,1,1},出现了重复的2和1。
如果出现极端情况,出现了N个2,那么在min_stack中也要存入N个2,浪费了大量的空间。
有什么方法解决这个问题吗?🧐
计数方法:和计数排序一样的原理。
例如:{5,3,2,2,2,6,4,1,1,1}
用一个结构体来记录:
struct val_count
{
int _val;//记录最小值
int _count://记录次数
};
在min_stack:{{5,1},{3,1},{2,3},{1,3}}——>前一个数字表示这个阶段的最小值,后面的数字表示这个阶段最小值出现的次数。
直到_count减到0,才删除min_stack的栈顶元素。
代码:
struct val_count
{
int _val;
int _count;
};
class MinStack {
public:
/** initialize your data structure here. */
MinStack() {}
void push(int val) {
st.push(val);
if(min_stack.empty()||val<(min_stack.top()._val))
{
vat_count temp={val,1};
min_stack.push(temp);
}
else
{
if(val==(min_stack.top()._val))
min_stack.top()._count++;
}
}
void pop() {
if(st.top()==min_stack.top()._val)
{
min_stack.top()._count--;
if(min_stack.top()._count==0)
min_stack.pop();
}
st.pop();
}
int top() {
return st.top();
}
int getMin() {
return min_stack.top()._val;
}
private:
stack<int> st;
//stack<int> min_stack;
stack<vat_count> min_stack;
};
到此结束啦