扩展堆栈（stack） O(1) 时间访问栈中最小值（或最大值）

问题描述：扩展stack的实现，完成正常的push，pop操作，新增访问最小（或最大）元素的接口Min（），使得push，pop，Min的时间复杂度都是O(1)。

问题分析：拿到这道题，我们最先的思考往往是，设计一个算法从栈中拿到最小值，所以开始考虑任何可以用来实现该功能的排序和查找算法。假设栈中有n个元素，一切排序和查找都不可能实现O(1)的时间复杂度找到最小值。

再看题目，既然是扩展stack的实现，stack是一种数据结构，一种数据的组织方式，扩展它，也就允许我们对其数据组织方式和存储内容作一些改变吧。所以我们就有了下面的思路：

把当前最小值存起来，并且在进行push和pop操作的时维护它。维护要求如下：

1、如果有比当前最小值大的元素入栈，当前最小值不变

2、如果有比当前最小值大的元素入栈，当前最小值变为新加入元素（考虑一下等于的时候啊，呵呵）

3、如果有比当前最小值大的元素出栈，当前最小值不变（注意：弹出的操作时，一定不可能弹出比当前最小值还小的元素，也就是说如果你弹出了一个比当前最小值还小的元素，就证明你的那个当前最小值不是当前最小值）

4、如果有和当前最小值的元素相同出栈，当前最小值变为当前当前最小值入栈之前那个最小值，当前最小值退出。

综上，我们发现一个规律：对于最小值而言，如果有更小的数入栈，需要将其保存为当前最小，如果当前最小数出栈，当前最小数变成

当前最小数入栈之前那个最小数，所以，对于最小数而言也具有先进后出，后进先出的特点，只是并不是每次push和pop操作都牵涉到

最小数的进出。所以我们考虑用双栈来实现，一个栈用来存放数据，满足栈数据结构原始要求，一个栈用来存放最小值，在每次push和

pop操作执行时，按照上面的规则维护最小值栈。

下面是扩展栈的实现：（O(1)的pop，push，和Min访问最小值操作）MinStack.h

[c-sharp]   view plain copy

1. #ifndef _H_MINSTACK_H_  
2. #define _H_MINSTACK_H_  
3. #include <iostream>  
4. template <class T>  
5. class MinStack  
6. {  
7.     public:  
8.         MinStack():MaxSize(20)  
9.         {  
10.             top=MinTop=-1;  
11.             stack=new T[MaxSize];  
12.             Mins=new T[MaxSize];      
13.         }  
14.         MinStack(int MaxSize);  
15.         ~MinStack()  
16.         {  
17.             delete [] stack;  
18.             delete [] Mins;  
19.         }  
20.         bool isEmpty(){return top==-1;}  
21.         bool isFull(){return top==(MaxSize-1);}  
22.         MinStack<T>& push(const T& x);  
23.         MinStack<T>& pop(T& x);  
24.         T Top(){return stack[top];}  
25.         T Min(){return Mins[MinTop];}  
26.     private:  
27.         int top,MinTop,MaxSize;  
28.         T *stack,*Mins;  
29. };  
30. template <class T>  
31. MinStack<T>::MinStack(int MaxSize)  
32. {  
33.     top=MinTop=-1;  
34.     this->MaxSize=MaxSize;  
35.     stack=new T[MaxSize];  
36.     Mins=new T[MaxSize];      
37. }  
38. template <class T>  
39. MinStack<T>& MinStack<T>::push(const T& x)  
40. {  
41.     if(isEmpty())  
42.     {  
43.         stack[++top]=x;  
44.         Mins[++MinTop]=x;  
45.     }  
46.     else  
47.     {  
48.         if(isFull())  
49.         {  
50.             std::cout<<"no space "<<std::endl;  
51.         }  
52.         else  
53.         {  
54.             stack[++top]=x;  
55.             if(x<=Mins[MinTop])//注意“==”时也要压入  
56.                 Mins[++MinTop]=x;  
57.         }  
58.     }  
59.     return *this;  
60. }  
61. template <class T>  
62. MinStack<T>& MinStack<T>::pop(T& x)  
63. {  
64.     if(isEmpty())  
65.     {  
66.         std::cout<<"Stack is empty"<<std::endl;  
67.     }  
68.     else  
69.     {  
70.         x=stack[top--];  
71.         if(x==Mins[MinTop])  
72.             --MinTop;  
73.     }  
74. }  
75. #endif //_H_MINSTACK_H_  

 

下面是测试（MinStacktest.cc）

[c-sharp]   view plain copy

1. #include <iostream>  
2. #include "MinStack.h"  
3.   
4. int main()  
5. {  
6.     MinStack<int> ms(20);  
7.     ms.push(20);ms.push(22);ms.push(18);  
8.     std::cout<<"the Minest value is "<<ms.Min()<<std::endl;  
9.     ms.push(11);ms.push(44);ms.push(5);  
10.     std::cout<<"the Minest value is "<<ms.Min()<<std::endl;  
11.     int x;  
12.     ms.pop(x);  
13.     std::cout<<"the Minest value is "<<ms.Min()<<std::endl;  
14.     return 0;  
15.   
16. }  

 

编译运行结果如下：

[jim@gpu1 stack]$ g++ -o MinStacktest MinStacktest.cc MinStack.h 
[jim@gpu1 stack]$ ./MinStacktest 
the Minest value is 18
the Minest value is 5
the Minest value is 11