数据结构---栈实现(源码)

第三章   栈

1. /*****************************SqList********************************** 
2. Date:2008.10.30 
3. Author:ZORO 
4. WebSite:http://blog.youkuaiyun.com/sevenhu 
6. ====================================================================== 
8. 参考资料： 
9. BOOK:数据结构(C语言版)     严蔚敏     清华大学出版社 
10. Page:47 
12. ====================================================================== 
13. ADT SqStack  { 
14.     InitStack(&S)
15.     DestroyStack(&S) 
16.     ClearStack(&S) 
17.     StackEmpty(S) 
18.     StackLength(S) 
19.     GetTop(S,&e)
20.     Push(&S,e)
21.     Pop(&S,&e)
22.     StackTraverse(S) 
23. }ADT SqStack 
24. ====================================================================== 
25. note:VC++ 6.0测试通过。 
26. *********************************************************************/ 
29. #include <iostream>
31. using namespace std;
34. #define     STACK_INIT_SIZE     100                                 //存储空间初始化量
35. #define     STACKINCREMENT      10                                  //存储空间增量
37. #define     OK                  1
38. #define     ERROR               0
39. #define     OVERFLOW            -1
40. #define     NULL                0
43. typedef int  Status;                                                //返回值标志
44. typedef bool BOOL;
46. typedef struct
47. {
48.     int * base;
49.     int * top;
50.     int stacksize;
51. }SqStack;
54. Status InitStack(SqStack &S)
55. {
56.     //构造一个空栈
57.     int * bp = (int *)malloc(STACK_INIT_SIZE * sizeof(int));        //分配空间
58.     
59.     if (bp == NULL)
60.     {
61.         exit(OVERFLOW);
62.     }
63.     else
64.     {
65.         S.top = S.base = bp;                                        //初始化
66.     }
68.     S.stacksize = STACK_INIT_SIZE;                                  //栈容量
69.     bp = NULL;
71.     return OK;
72. }//InitStack
75. Status DestroyStack(SqStack &S)
76. {
77.     //销毁栈
78.     int * bp = S.base ;
80.     free(bp);                                                       //释放空间
82.     bp = S.base = S.top = NULL;                                     //销毁栈信息
83.     S.stacksize = 0;
85.     return OK;
86. }//DestroyStack
89. Status ClearStack(SqStack &S)
90. {
91.     //清空栈
92.     S.top = S.base;
93.     return OK;
94. }//ClearStack
97. BOOL StackEmpty(SqStack S)
98. {
99.     //判断栈空
100.     if (S.base == S.top )
101.     {
102.         return true;
103.     }
104.     else
105.     {
106.         return false;
107.     }
108. }//StackEmpty
111. int StackLength(SqStack S)
112. {
113.     //反回栈的长度
114.     int i = 0;
115.     int * pbase = S.base ;
116.     int * ptop = S.top ;
118.     while (pbase != ptop) {
119.         ++i;
120.         ++pbase;
121.     }
123.     pbase = ptop = NULL;
125.     return i;
126. }//StackLength
129. Status GetTop(SqStack S, int &e)
130. {
131.     //e返回栈顶元素
132.     if (StackEmpty(S))
133.     {
134.         return ERROR;
135.     }
136.     else
137.     {
138.         e = *(S.top - 1);
139.         return OK;
140.     }
141. }//GetTop
144. Status Push(SqStack &S, int e)
145. {
146.     //插入元素e到栈顶
147.     int * pb = NULL;
148.     if (S.top - S.base >= S.stacksize )
149.     {
150.         pb = (int *)realloc(S.base, 
151.                 (S.stacksize + STACKINCREMENT) * sizeof(int));      //追加空间
152.         if (pb == NULL)
153.         {
154.             exit(OVERFLOW);
155.         }
156.         else
157.         {
158.             S.base = pb;                                            //新栈底指针位置
159.             S.top = S.base + S.stacksize ;                          //确定top位置
160.             S.stacksize += STACKINCREMENT;
161.         }
162.     }
164.     *S.top++ = e;                                               //插入元素，栈顶指针上移
165.     pb = NULL;
166.     return OK;
167. }//Push
170. Status Pop(SqStack &S, int &e)
171. {
172.     //弹出栈顶元素给e
173.     if (StackEmpty(S))
174.     {
175.         return ERROR;
176.     }
177.     else
178.     {
179.         e = *--S.top ;                                              //栈顶指针下移,返回元素
180.         return OK;
181.     }
182. }//Pop
184. Status StackTraverse(SqStack S)
185. {
186.     //遍历栈
187.     int * pb = NULL;
188.     if (StackEmpty(S))
189.     {
190.         return ERROR;
191.     }
192.     else
193.     {
194.         pb = S.base;
195.     
196.         while (pb != S.top)
197.         {
198.             cout << *pb++ << " ";                                   //输出当前元素，并把指针上移
199.         }
200.         cout << endl;
202.         return OK;
203.     }
204. }//StackTraverse
206. int main()
207. {
208.     SqStack S;
209.     InitStack(S);
210.     
211.     for (int i=0; i<10; ++i)
212.     {
213.         Push(S,i);
214.     }
215.     
216.     cout << "压栈成功!" << endl;
217.     StackTraverse(S);
219.     cout << "弹出2个元素" << endl;
220.     int e = 0;
221.     for (i=0; i<2; ++i)
222.     {
223.         Pop(S,e);
224.         cout << e << endl;
225.     }
227.     cout << "弹出成功!" << endl;
228.     StackTraverse(S);
232.     cout << "栈的长度:" << StackLength(S) << endl;
234.     GetTop(S,e);
235.     cout << "栈顶元素是" << e << endl;
237.     cout << "清空栈..." << endl;
238.     ClearStack(S);
241.     cout << "重新压栈!" << endl;
242.     for (i=10; i>0; --i)
243.     {
244.         Push(S,i);
245.     }
246.     StackTraverse(S);
248.     cout << "销毁栈..." << endl;
249.     DestroyStack(S);
251.     return 0;
252. }