栈的顺序存储结构——双栈

栈的顺序存储结构——双栈。

 

双栈的图片：

 

BothStack.h

[cpp] view plain copy

1. const int StackSize=100;  //100只是示例数据，需根据具体问题定义  
2. template <class T>  
3. class BothStack   
4. {  
5. public:  
6.     BothStack( ) {top1= -1;  top2=StackSize;}  //构造函数，将两个栈分别初始化  
7.     ~BothStack( ) { }      //析构函数  
8.     void Push(int i, T x);   //将元素x压入栈i  
9.     T Pop(int i);          //对栈i执行出栈操作  
10.     T GetTop(int i);       //取栈i的栈顶元素  
11.     bool Empty(int i);     //判断栈i是否为空栈  
12. private:  
13.     T data[StackSize];     //存放两个栈的数组  
14.     int top1, top2;        //两个栈的栈顶指针，分别指向各自的栈顶元素在数组中的下标  
15. };  
16.   
17. #endif  

 

 

BothStack.cpp

[cpp] view plain copy

1. //BothStack.cpp  
2. #include "BothStack.h"  
3.   
4. /* 
5.  * 前置条件：栈不存在 
6.  * 输    入：无 
7.  * 功    能：栈的初始化 
8.  * 输    出：无 
9.  * 后置条件：构造一个空栈 
10.  */  
11.   
12. template <class T>  
13. BothStack<T>::BothStack( )  
14. {  
15.     top1= -1;    
16.     top2=StackSize;  
17. }   
18.   
19. /* 
20.  * 前置条件：共享空间已存在 
21.  * 输    入：无 
22.  * 功    能：销毁两栈共享的数组空间 
23.  * 输    出：无 
24.  * 后置条件：将两栈共享的数组空间释放 
25.  */  
26.   
27. template <class T>  
28. BothStack<T>::~BothStack( )   
29. {  
30.   
31. }  
32.   
33. /*  
34.  * 前置条件：共享空间已存在 
35.  * 输    入：栈号i，元素值x 
36.  * 功    能：在栈i顶插入一个元素x 
37.  * 输    出：若插入不成功，则抛出插入异常 
38.  * 后置条件：若插入成功，则栈i顶插入了一个栈顶元素 
39.  */  
40.   
41. template <class T>   
42. void BothStack<T>::Push(int i, T x )  
43. {  
44.     if (top1==top2-1)   
45.         throw "上溢";  
46.     if (i==1)   
47.         data[++top1]=x;  
48.     if (i==2)   
49.         data[--top2]=x;  
50. }  
51.   
52. /* 
53.  * 前置条件：共享空间已存在 
54.  * 输    入：栈号i 
55.  * 功    能：在栈i中删除栈顶元素 
56.  * 输    出：若删除不成功，则抛出删除异常 
57.  * 后置条件：若删除成功，则栈i中删除了栈顶元素 
58.  */  
59.   
60. template <class T>  
61. T BothStack<T>::Pop(int i)  
62. {  
63.     if (i==1) //将栈1的栈顶元素出栈  
64.     {     
65.         if (top1== -1)   
66.             throw "下溢";  
67.         return data[top1--];  
68.     }  
69.     if (i==2)  //将栈2的栈顶元素出栈  
70.     {                             
71.         if (top2==StackSize)   
72.             throw "下溢";  
73.         return data[top2++];   
74.     }  
75. }  
76.   
77. /* 
78.  * 前置条件：共享空间已存在 
79.  * 输    入：栈号i 
80.  * 功    能：读取栈i当前的栈顶元素 
81.  * 输    出：若栈i不空，返回栈i当前的栈顶元素值 
82.  * 后置条件：两栈均不变 
83.  */  
84.   
85. template <class T>   
86. T BothStack<T>::GetTop(int i)  
87. {  
88.     if(i==1)  
89.     {  
90.         if (top1!=-1)   
91.             return data[top1];  
92.     }  
93.     if(i==2)  
94.     {  
95.         if(top2!=StackSize)  
96.             return data[top2];  
97.    }   
98. }  
99.   
100. /* 
101.  * 前置条件：共享空间已存在 
102.  * 输    入：栈号i 
103.  * 功    能：判断栈i是否为空栈 
104.  * 输    出：若栈i为空栈，返回1；否则返回0 
105.  * 后置条件：两栈均不变 
106.  */  
107.   
108. template <class T>   
109. bool BothStack<T>::Empty(int i)  
110. {    
111.     if(i==1)  
112.     {  
113.         if(top1==-1)   
114.             return 0;  
115.         else   
116.             return 1;  
117.     }  
118.     if(i==2)  
119.     {  
120.         if(top2==StackSize)  
121.             return 0;  
122.         else   
123.             return 1;  
124.     }  
125. }