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)最后

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

你可能感兴趣的:(leetcode,c++,leetcode)