栈和队列（1）——一个有getMin功能的栈

要求：

1.pop、push、getMin操作的时间复杂度都是O(1);

2.设计的栈类型可以使用现成的栈结构。

思考：

可以使用两个栈，一个用来保存当前栈中的元素，器其功能和一个正常的栈没区别，记为stackData；另一个用于保存每一步的最小值，这个栈记为stackMin。

方法一：

假设当前数据为newNum，先将其压入stackData，然后比较stackMin栈里面栈顶元素，如果stackMin是空的，就把newNum压入，如果不是，比较newNum和stackMin栈顶的元素，小就压入，大不不管。一次压入，把所有数据压完。

最后得到的stackMin的数据是从栈顶到栈底依次增大的，我们按照以下的数据规则将数据弹出：取stackData栈顶的元素，记为value，比较value和stackMin栈顶的元素。如果value等于stackMin栈顶的元素时，stackMin弹出栈顶元素；当value大于stackMin的栈顶元素时，stackMin不弹出栈顶元素；返回value。

仔细思考可得，stackMin始终记录着stackData里面最小值。所以stackMin的栈顶元素始终是当前stackData中的最小值。

例如：





代码实现：

<java>

package algorithm_1;
import java.util.*;
public class MyStack1
{
public Stack<Integer> stackData;
public Stack<Integer> stackMin;
public MyStack1()
{
this.stackData = new Stack<Integer>();
this.stackMin = new Stack<Integer>();
}
public void push(int newNum)
{
if(this.stackMin.isEmpty())
{
this.stackMin.push(newNum);
}
else if (newNum <=this.getmin())
{
this.stackMin.push(newNum);
}
this.stackData.push(newNum);
}
public int pop()
{
if(this.stackData.isEmpty())
{
throw new RuntimeException("Your stack is empty");
}
int value = this.stackData.pop();
if(value == this.getmin())
{
this.stackMin.pop();
System.out.println(value);
}
return value;
}
public int getmin()
{
if(this.stackMin.isEmpty())
{
throw new RuntimeException("Your stack is empty");
}
return this.stackMin.peek();
}

}

测试主函数：

package algorithm_1;
import algorithm_1.MyStack1;
public class algorithm_1 {
public static void main(String[] args){
MyStack1 mytest ;
mytest = new MyStack1();
mytest.push(3);
mytest.push(5);
mytest.push(6);
mytest.push(2);
mytest.push(1);
mytest.push(5);
System.out.println("stackMin_in = ");
System.out.println(mytest.stackMin);
System.out.println("stackMin_out = ");
for(int i = 0;i<6;i++)
{
mytest.pop();

}
}
}

测试结果：

<C++>

方法二：

假设当前数据为newNum，将其压入stackData，然后判断stackMin是否为空。

如果为空则newNum压入stackMin；如果不为空，则比较newNum和stackMin的栈顶元素。如果newNum更小或者两者相等，则newNum也压入stackMin；如果stackMin中栈顶元素小，则把stackMin的栈顶元素重复压入stackMin。

在stackData中弹出数据，弹出的数据记为value；弹出的stackMin中的栈顶；返回value。stackMin始终几率这stackData中的最小值，所以stackMin的栈顶元素始终是当前stackData中的最小值。



代码实现：

<java>

package algorithm_1;
import java.util.*;
public class MyStack2
{
public Stack<Integer> stackData;
public Stack<Integer> stackMin;
public MyStack2()
{
this.stackData = new Stack<Integer>();
this.stackMin = new Stack<Integer>();
}
public void push(int newNum)
{
if(this.stackMin.isEmpty())
{
this.stackMin.push(newNum);
}
else if (newNum < this.getmin())
{
this.stackMin.push(newNum);
}
<span style="color:#ff0000;">		else
{
int newMin = this.stackMin.peek();
this.stackMin.push(newMin);
}
this.stackData.push(newNum);</span>
}
public int pop()
{
if(this.stackData.isEmpty())
{
throw new RuntimeException("Your stack is empty");
}

System.out.println(this.stackMin.pop());
return this.stackData.pop();
}
public int getmin()
{
if(this.stackMin.isEmpty())
{
throw new RuntimeException("Your stack is empty");
}
return this.stackMin.peek();
}

}

测试主函数：

package algorithm_1;
import algorithm_1.MyStack2;
public class algorithm_1 {
public static void main(String[] args){
MyStack2 mytest ;
mytest = new MyStack2();
mytest.push(3);
mytest.push(5);
mytest.push(6);
mytest.push(2);
mytest.push(1);
mytest.push(5);
System.out.println("stackMin_in = ");
System.out.println(mytest.stackMin);
System.out.println("stackMin_out = ");
for(int i = 0;i<6;i++)
{
mytest.pop();

}

}
}

测试结果：



总结：

方法一和二其实都是用stackMin保存着stackData每一步的最小值。共同点是所有的时间复杂度都为O(1)、空间复杂度都为O(n)。区别是：方案一种的stackMin压入时省空间，但是弹出操作费时间；方案二stackMin压入稍费空间，但是弹出省时间。