题目

面试官：小夕，做一下这道面试题吧。

小夕：好的,我可以借助辅助栈来实现吗？

面试官：可以的，说一下你的思路吧。

小夕：好的，我图形结合一下，说得清楚些。

第一种辅助栈思路

小夕：

• 维护两个栈，一个输入栈A，一个辅助栈B，辅助栈用于存储当前栈中的最小值

• 每次元素 x 入栈，输入栈 A 直接入栈

• 辅助栈 B 入栈时为空直接入栈，如果 B 不为空，首先取 B 的栈顶元素 min，如果 x 大于min，那么辅助栈 B 继续入栈 min 值，如果 x 小于等于 min，那么辅助栈 B 入栈 x

• 这样辅助栈 B 中每次入栈的元素都是当前栈的最小值

• 这样取栈的 min 值时， 直接返回 B 的栈顶元素即可，时间复杂度是 O(1)

• pop 出栈的话 栈 A 和 栈 B 都出栈，也是时间复杂度是 O(1)，push 入栈时间复杂度也是 O(1)

拿题目中[-2,0,-3]举例。

第一种辅助栈图解思路

动画

代码

Java

class MinStack {Stack<Integer> A, B;/** initialize your data structure here. */public MinStack() {A = new Stack<>();B = new Stack<>();}public void push(int x) {A.push(x);if (B.empty() || x < B.peek()) { // 辅助栈B为空 或者x小于B的栈顶元素，那么把x入B栈，这样B顶部始终是最小值B.push(x);} else {B.push(B.peek());  // x比B栈顶元素大，那么B栈顶是最小元素，继续B继续入一个栈顶的最小元素。}}public void pop() { A.pop();B.pop();}public int top() {return A.peek();}public int min() { // B栈顶维护了一个最小值return B.peek();}
}/*** Your MinStack object will be instantiated and called as such:* MinStack obj = new MinStack();* obj.push(x);* obj.pop();* int param_3 = obj.top();* int param_4 = obj.min();*/

C++

class MinStack {
public:stack<int> stk,min_stk;//stk为原栈，min_stk为记录每次最小值的栈/** initialize your data structure here. */MinStack() {}void push(int x) {stk.push(x);if(min_stk.size()) x=min(x,min_stk.top());//x表示当前的最小值min_stk.push(x);}void pop() {min_stk.pop();stk.pop();}int top() {return stk.top();//返回原栈的栈顶}int getMin() {return min_stk.top();//返回每次最小值的栈的栈顶}
};

Python

class MinStack:def __init__(self):"""initialize your data structure here."""self.A = []self.B=[]def push(self, x: int) -> None:self.A.append(x)if not self.B or  self.B[-1]>x:self.B.append(x)else:self.B.append(self.B[-1])def pop(self) -> None:self.A.pop();self.B.pop();def top(self) -> int:return self.A[-1]def min(self) -> int:return self.B[-1]

Go

type MinStack struct {elems []intmins []int
}/** initialize your data structure here. */
func Constructor() MinStack {return MinStack{make([]int,0),make([]int,0)}
}func (this *MinStack) Push(x int)  {this.elems = append(this.elems, x)if len(this.mins) == 0 || this.GetMin() >= x {this.mins = append(this.mins, x)} else {this.mins = append(this.mins, this.GetMin())}}func (this *MinStack) Pop()  {this.elems = this.elems[:len(this.elems)-1]this.mins = this.mins[:len(this.mins)-1]
}func (this *MinStack) Top() int {return this.elems[len(this.elems) - 1 ]
}func (this *MinStack) GetMin() int {return this.mins[len(this.mins)-1]
}

JS

/** * 解法1  辅助栈
*/
var MinStack = function() {this.stack1 = [];this.stack2 = [];
};/** * @param {number} x* @return {void}*/
MinStack.prototype.push = function(x) {this.stack1.push(x);const stack2Len = this.stack2.length;if (stack2Len === 0 || this.stack2[stack2Len - 1] >= x) {this.stack2.push(x);} else {this.stack2.push(this.stack2[stack2Len - 1]);}
};/*** @return {void}*/
MinStack.prototype.pop = function() {if (this.stack1.pop() === this.stack2[this.stack2.length - 1]) {this.stack2.pop();}
};/*** @return {number}*/
MinStack.prototype.top = function() {return this.stack1[this.stack1.length - 1];
};/*** @return {number}*/
MinStack.prototype.min = function() {return this.stack2[this.stack2.length - 1];
};

面试官：不错，你这个时间复杂度每个都是O(1)，由于借助了辅助栈，空间复杂度是 O(n)。那你能否在你的借助辅助栈的基础上优化一下呢？小夕: 不是很会啊

第二种辅助栈图解思路

小夕：面试官，想请教一下这个算法该如何优化。。。面试官：借助辅助栈的思路确实不错，但是辅助栈其实不用每次都压入一个元素，每次只压入当前栈最小值即可。我给你画几张图就很容易记录了~ 小夕：好的，辛苦辛苦！！！

图解思路

动画

面试官：题解思路就是这些，代码你写一下，我看你理解到尾没。

小夕：好的。

第二种代码

C

#define max_size 10000
//x_stack存储正常入栈元素，min_stack用来存储入栈时栈中最小的元素
//x_top和min_top分别为栈顶的下标
//min_value用来存储最小值
typedef struct {int *x_stack;int *min_stack;int x_top;int min_top;int min_value;
} MinStack;/** initialize your data structure here. */MinStack* minStackCreate() {MinStack *obj = (MinStack*)malloc(sizeof(MinStack));obj->x_stack = (int*)malloc(sizeof(int) * max_size);obj->min_stack = (int*)malloc(sizeof(int) * max_size);obj->min_top = obj->x_top = -1;obj->min_value = 0;return obj;
}void minStackPush(MinStack* obj, int x) {if(obj->x_top < max_size){if(obj->x_top == -1)obj->min_value = x;obj->x_stack[++(obj->x_top)] = x;if(x < obj->min_value)obj->min_value = x;     //当前元素比min_value小时改变min_valueobj->min_stack[++(obj->min_top)] = obj->min_value;}
}void minStackPop(MinStack* obj) {--(obj->x_top);--(obj->min_top);if(obj->min_top != -1)obj->min_value = obj->min_stack[obj->min_top];//出栈后将min_value变成min_stack的栈顶元素
}int minStackTop(MinStack* obj) {return obj->x_stack[obj->x_top];
}int minStackMin(MinStack* obj) {return obj->min_stack[obj->min_top];
}void minStackFree(MinStack* obj) {free(obj->x_stack);free(obj->min_stack);free(obj);
}/*** Your MinStack struct will be instantiated and called as such:* MinStack* obj = minStackCreate();* minStackPush(obj, x);* minStackPop(obj);* int param_3 = minStackTop(obj);* int param_4 = minStackMin(obj);* minStackFree(obj);
*/

Java

class MinStack {Stack<Integer> A, B;public MinStack() {A = new Stack<>();B = new Stack<>();}public void push(int x) {A.add(x);if(B.empty() || B.peek() >= x)B.add(x);}public void pop() {if(A.pop().equals(B.peek()))B.pop();}public int top() {return A.peek();}public int min() {return B.peek();}
}

JS

// ac地址：https://leetcode-cn.com/problems/bao-han-minhan-shu-de-zhan-lcof/
// 原文地址：https://xxoo521.com/2020-01-31-stack-min//*** initialize your data structure here.*/
var MinStack = function() {this.dataStack = [];this.minStack = []; // 辅助栈
};/*** @param {number} x* @return {void}*/
MinStack.prototype.push = function(x) {this.dataStack.push(x);const length = this.minStack.length;if (!length) {this.minStack.push(x);} else if (x <= this.minStack[length - 1]) {this.minStack.push(x);}
};/*** @return {void}*/
MinStack.prototype.pop = function() {const { minStack, dataStack } = this;if (minStack[minStack.length - 1] === dataStack[dataStack.length - 1]) {minStack.pop();}dataStack.pop();
};/*** @return {number}*/
MinStack.prototype.top = function() {const length = this.dataStack.length;if (length) {return this.dataStack[length - 1];} else {return null;}
};/*** @return {number}*/
MinStack.prototype.min = function() {const length = this.minStack.length;if (!length) return null;return this.minStack[length - 1];
};

Python

class MinStack:def __init__(self):self.stack = []def push(self, x: int) -> None:if not self.stack:self.stack.append((x,x))else:min_num = self.min()if x <= self.min():self.stack.append((x,x))else:self.stack.append((x,min_num))def pop(self) -> None:self.stack.pop(-1)def top(self) -> int:return self.stack[-1][0]def min(self) -> int:return self.stack[-1][1]

第三种使用单栈来实现

面试官：不错不错，你这里借助了辅助栈去实现，这道面试题你想一想有没有不借助辅助栈，只使用一个辅助栈的实现思路？

小夕：只使用一个栈还能实现？？？

面试官：我提醒你一下，当压栈的值小于栈中最小值时，先把最小值入栈，然后再把需要压栈的值入栈，最后再更新栈中最小值。如果压栈的值大于栈中最小值的时候，直接压栈。

小夕：哦哦哦！！！我好像知道是怎么回事了，我画几张图，辛苦面试官看看小夕理解的对不对。

图解思路

动画

第三种使用单栈来实现代码

Java

class MinStack {//push方法可能会加入很多minint min = Integer.MAX_VALUE;Stack<Integer> stack = new Stack<>();public void push(int x) {//如果加入的值小于最小值，要更新最小值if (x <= min) {stack.push(min);min = x;}stack.push(x);}public void pop() {//如果把最小值出栈了，就更新最小值if (stack.pop() == min)min = stack.pop();}public int top() {return stack.peek();}public int min() {return min;}
}

C++

class MinStack {
public:int min=0x3f3f3f3f;stack<int> stk;//stk栈/** initialize your data structure here. */MinStack() {}void push(int x) {//如果加入的值小于最小值，要更新最小值if (x <= min) {stk.push(min);min = x;}stk.push(x);}void pop() {//如果把最小值出栈了，就更新最小值int p = stk.top();stk.pop();if (p == min){min = stk.top();stk.pop();}}int top() {return stk.top();//返栈的栈顶}int getMin() {return min;//返回栈的栈顶}
};

Python

class MinStack:def __init__(self):"""initialize your data structure here."""self.min_value =float('inf')self.stack = []def push(self, x: int) -> None:if x<=self.min_value:self.stack.append(self.min_value)self.min_value = xself.stack.append(x);def pop(self) -> None:if self.stack.pop()==self.min_value:self.min_value = self.stack.pop()def top(self) -> int:return self.stack[-1]def min(self) -> int:return self.min_value

JS

/** * 解法3  单调栈
*/
var MinStack = function() {this.stack = [];this.min = Number.MAX_SAFE_INTEGER;
};/** * @param {number} x* @return {void}*/
MinStack.prototype.push = function(x) {if (x < this.min) {this.min = x;}this.stack.push(x);
};/*** @return {void}*/
MinStack.prototype.pop = function() {if (!this.stack.length) return;const curValue = this.stack.pop();if (this.min === curValue) {this.min = Math.min(...this.stack);}
};/*** @return {number}*/
MinStack.prototype.top = function() {const len = this.stack.length;if (!len) return Infinity;return this.stack[len - 1];
};/*** @return {number}*/
MinStack.prototype.min = function() {return this.min;
};

Go

// 单个栈
type MinStack struct {stack []int;
}/** initialize your data structure here. */
func Constructor() MinStack {return MinStack{make([]int,0)}
}func (this *MinStack) Push(x int)  {if len(this.stack)==0 || this.GetMin()>x {this.stack = append(this.stack,x,x)}else{this.stack = append(this.stack,this.GetMin(),x)}}func (this *MinStack) Pop()  {this.stack = this.stack[:len(this.stack)-2]
}func (this *MinStack) Top() int {return this.stack[len(this.stack)-1]
}func (this *MinStack) GetMin() int {return this.stack[len(this.stack)-2]
}

自定义链表节点

面试官：不错，就是这个意思，代码也写得不错，还会这么多语言，厉害了。面试官：其实这道题我之前还见过一个自己定义链表的数据结构的解法。小夕：啊，面试官真是见多识广 面试官：你只需要定义一个链表节点，这个链表节点的定义我给你定义出来，你根据这个结构就知道怎么做了！小夕：谢谢面试官！我按照这个节点定义说一下我的思路。

链表节点定义

class ListNode {public int val;public int min;//最小值public ListNode next;public ListNode(int val, int min, ListNode next) {this.val = val;this.min = min;this.next = next;}
}

图解思路

动画

代码

Java

class MinStack {//链表头，相当于栈顶private ListNode head;//压栈，需要判断栈是否为空public void push(int x) {if (empty())head = new ListNode(x, x, null);elsehead = new ListNode(x, Math.min(x, head.min), head);}//出栈，相当于把链表头删除public void pop() {if (empty())throw new IllegalStateException("栈为空……");head = head.next;}//栈顶的值也就是链表头的值public int top() {if (empty())throw new IllegalStateException("栈为空……");return head.val;}//链表中头结点保存的是整个链表最小的值，所以返回head.min也就是//相当于返回栈中最小的值public int min() {if (empty())throw new IllegalStateException("栈为空……");return head.min;}//判断栈是否为空private boolean empty() {return head == null;}
}class ListNode {public int val;public int min;//最小值public ListNode next;public ListNode(int val, int min, ListNode next) {this.val = val;this.min = min;this.next = next;}
}

Python

class MinStack:def __init__(self):"""initialize your data structure here."""self.head = Nonedef push(self, x: int) -> None:if not self.head:self.head = ListNode(x,x,None)else:p = ListNode(x,min(x,self.head.min_val),self.head)self.head = p    def pop(self) -> None:self.head = self.head.nextdef top(self) -> int:return self.head.valdef min(self) -> int:return self.head.min_valclass ListNode:def __init__(self,x=None,min_val=None,next=None):self.val = xself.min_val = min_valself.next = next

JS

/** * 解法2  链表
*/
class LinkNode {constructor(val, min) {this.val = val;this.min = min;this.next = null;}
}var MinStack = function () {this.head = null;
};/*** @param {number} x* @return {void}*/
MinStack.prototype.push = function(x) {if (this.head === null) {this.head = new LinkNode(x, x);} else {const temp = new LinkNode(x, Math.min(x, this.head.min));[temp.next, this.head] = [this.head, temp];}
};/*** @return {void}*/
MinStack.prototype.pop = function() {if (this.head !== null) {this.head = this.head.next;}
};/*** @return {number}*/
MinStack.prototype.top = function() {if (this.head !== null) {return this.head.val;}return Infinity;
};/*** @return {number}*/
MinStack.prototype.min = function() {if (this.head !== null) {return this.head.min;}return -Infinity;
};

小夕：面试官，你看我说得对不对。

面试官：不错不错，就是这个样子。

小夕：谢谢面试官，面试官你这么厉害