数据结构之栈

1．栈

 

1.1 栈的定义

栈是一种特殊的线性表。其特殊性在于限定插入和删除数据元素的操作只能在线性表的一端进行。如下所示：

结论：后进先出（Last In First Out），简称为LIFO线性表。

 

栈的基本运算有六种：

构造空栈：InitStack(S)、

判栈空: StackEmpty(S)、

判栈满： StackFull(S)、

进栈： Push(S,x)、可形象地理解为压入，这时栈中会多一个元素

退栈： Pop(S) 、 可形象地理解为弹出，弹出后栈中就无此元素了。

取栈顶元素：StackTop(S),不同与弹出，只是使用栈顶元素的值，该元素仍在栈顶不会改变。

    由于栈也是线性表，因此线性表的存储结构对栈也适用，通常栈有顺序栈和链栈两种存储结构，这两种存储结构的不同，则使得实现栈的基本运算的算法也有所不同。

 

我们要了解的是，在顺序栈中有"上溢"和"下溢"的概念。顺序栈好比一个盒子，我们在里头放了一叠书，当我们要用书的话只能从第一本开始拿(你会把盒子翻过来吗?真聪明^^)，那么当我们把书本放到这个栈中超过盒子的顶部时就放不下了(叠上去的不算，哼哼)，这时就是"上溢","上溢"也就是栈顶指针指出栈的外面，显然是出错了。反之，当栈中已没有书时，我们再去拿，看看没书，把盒子拎起来看看盒底，还是没有，这就是"下溢"。"下溢"本身可以表示栈为空栈,因此可以用它来作为控制转移的条件。

链栈则没有上溢的限制，它就象是一条一头固定的链子，可以在活动的一头自由地增加链环(结点)而不会溢出，链栈不需要在头部附加头结点，因为栈都是在头部进行操作的，如果加了头结点，等于要在头结点之后的结点进行操作，反而使算法更复杂，所以只要有链表的头指针就可以了。

1.2 栈的顺序存储

使用c++的面向对象封装：

 

1. // Test.cpp : Defines the entry point for the console application.  
2. //  
3. #include "stdafx.h"    
4. #include   
5. using namespace std;  
6. #define MAX 10 // MAXIMUM STACK CONTENT  
7. class stack     
8. {     
9. private:     
10.     int arr[MAX];   
11.     int top;   
12. public:     
13.     stack()   
14.     {     
15.         inItStack();   
16.     }  
17.       
18.       
19.       
20.     void inItStack()   
21.     {   
22.         top=-1;   
23.     }   
24.       
25.       
26.       
27.     void push(int a)   
28.     {     
29.         top++;  
30.         if(top < MAX)  {     
31.             arr[top]=a;   
32.         }   else   {     
33.             cout<<"STACK FULL!!"<<top;     
34.         }     
35.     }     
36.       
37.       
38.       
39.     int pop()  
40.     {      
41.         if(isEmpty())   {     
42.             cout<<"STACK IS EMPTY ";  
43.             return NULL;     
44.         } else {     
45.             int data=arr[top];   
46.             arr[top]=NULL;   
47.             top--;  
48.             return data;   
49.         }     
50.     }     
51.   
52.       
53.       
54.       
55.     bool isEmpty()  
56.     {  
57.         if(top == -1) return true;  
58.         else return false;  
59.     }  
60. };     
61. int main()     
62. {     
63.     stack a;     
64.     a.push(3);     
65.     a.push(10);     
66.     a.push(1);     
67.     cout<<"Pop:"<<a.pop();        
68.     return 0;     
69. }  

结论：由于栈的插入和删除操作具有它的特殊性，所以用顺序存储结构表示的栈并不存在插入删除数据元素时需要移动的问题，但栈容量难以扩充的弱点仍就没有摆脱。

 

1.3 栈的链式存储
若是栈中元素的数目变化范围较大或不清楚栈元素的数目，就应该考虑使用链式存储结构。人们将用链式存储结构表示的栈称作"链栈"。链栈通常用一个无头结点的单链表表示。如图所示：

栈的操作是线性表操作的特例。

简单用c实现：

 

1. // Test.cpp : Defines the entry point for the console application.    
2. //    
3. #include "stdafx.h"    
4. #include     
5. #include "stdlib.h"  
6. #include   
7. using namespace std;  
8. //宏定义    
9. #define TRUE   1    
10. #define FALSE   0    
11. #define OK    1    
12. #define ERROR   0    
13. #define INFEASIBLE -1    
14. #define OVERFLOW -2   
15. #define STACKEMPTY -3    
16.   
17. #define LT(a,b)   ((a)<(b))    
18. #define N = 100           
19.   
20. typedef int Status;    
21. typedef int ElemType;    
22.   
23. typedef struct LNode{    
24.     ElemType        data;                 
25.     struct LNode   *next;       
26. }LNode, *LinkList;   
27.   
28. typedef struct stack{  
29.     LinkList top;  
30. } STACK;  
31.   
32.   
33.   
34.   
35.   
36. void InitStack(STACK &S);  
37. void Push(STACK &S,ElemType e);  
38. void Pop(STACK &S, ElemType *e);  
39. ElemType GetTop(STACK S,ElemType *e);  
40. int StackEmpty(STACK S);  
41.   
42.   
43.   
44.   
45. void InitStack(STACK &S)  
46. {  
47.     S.top=NULL;  
48. }  
49.   
50.   
51.   
52.   
53. void Push(STACK &S,ElemType e)  
54. {  
55.     LinkList p;  
56.     p = (LinkList )malloc(sizeof(LNode));  
57.     if (!p) exit(OVERFLOW);  
58.     p->data = e;  
59.     p->next = S.top;  
60.     S.top = p;  
61. }  
62.   
63.   
64.   
65. void Pop(STACK &S, ElemType *e)  
66. {  
67.     LinkList p;  
68.     if(StackEmpty(S)) exit(STACKEMPTY);  
69.     *e = S.top->data;  
70.     p = S.top;  
71.     S.top = p->next;   
72.     free(p);  
73. }  
74.   
75.   
76.   
77. ElemType GetTop(STACK S, ElemType *e)  
78. {  
79.     if(StackEmpty(S)) exit(STACKEMPTY);  
80.     *e = S.top->data;  
81. }  
82.   
83.   
84.   
85.   
86. int StackEmpty(STACK S)   
87. {  
88.     if(S.top==NULL) return TRUE;  
89.     return   FALSE;  
90. }  
91.   
92. void main()    
93. {    
94.   
95.     STACK S;  
96.     InitStack( S);  
97.     Push(S, 3);  
98.     Push(S, 4);  
99.     ElemType e;  
100.     Pop(S,&e);  
101.     cout<<"Pop elem:"<<e;  
102. }    

1.4 栈的应用

1)  数制转换

2）语法词法分析

3）表达式求值等

1.5 栈的递归和实现

汉诺塔的问题：

解决：

1）如果有一个盘子，直接从X移到Z即可。
2）如果有n个盘子要从X移到Z，Y作为辅助。问题可以转化为，先将上面n-1个从X移动到Y，Z作为辅助，然后将第n个从X移动到Z，最后将剩余的n-1个从Y移动到Z，X作为辅助。

完整实现代码，包括栈的实现：

 

1. // Test.cpp : Defines the entry point for the console application.    
2. //    
3. #include "stdafx.h"    
4. #include     
5. #include "stdlib.h"  
6. #include   
7. using namespace std;  
8. //宏定义    
9. #define TRUE   1    
10. #define FALSE   0    
11. #define OK    1    
12. #define ERROR   0    
13. #define INFEASIBLE -1    
14. #define OVERFLOW -2   
15. #define STACKEMPTY -3    
16.   
17. #define LT(a,b)   ((a)<(b))    
18. #define N = 100           
19.   
20. typedef int Status;    
21. typedef int ElemType;    
22.   
23. typedef struct LNode{    
24.     ElemType        data;                 
25.     struct LNode   *next;       
26. }LNode, *LinkList;   
27.   
28. typedef struct stack{  
29.     LinkList top;  
30. } STACK;  
31.   
32.   
33.   
34.   
35.   
36. void InitStack(STACK &S);  
37. void Push(STACK &S,ElemType e);  
38. void Pop(STACK &S, ElemType *e);  
39. ElemType GetTop(STACK S,ElemType *e);  
40. int StackEmpty(STACK S);  
41.   
42.   
43.   
44.   
45. void InitStack(STACK &S)  
46. {  
47.     S.top=NULL;  
48. }  
49.   
50.   
51.   
52.   
53. void Push(STACK &S,ElemType e)  
54. {  
55.     LinkList p;  
56.     p = (LinkList )malloc(sizeof(LNode));  
57.     if (!p) exit(OVERFLOW);  
58.     p->data = e;  
59.     p->next = S.top;  
60.     S.top = p;  
61. }  
62.   
63.   
64.   
65. void Pop(STACK &S, ElemType *e)  
66. {  
67.     LinkList p;  
68.     if(StackEmpty(S)) exit(STACKEMPTY);  
69.     *e = S.top->data;  
70.     p = S.top;  
71.     S.top = p->next;   
72.     free(p);  
73. }  
74.   
75.   
76.   
77. ElemType GetTop(STACK S, ElemType *e)  
78. {  
79.     if(StackEmpty(S)) exit(STACKEMPTY);  
80.     *e = S.top->data;  
81. }  
82. void printStack(STACK S){  
83.     LinkList p;  
84.     p = S.top;  
85.     printf("栈： ");  
86.     while (p) {  
87.         printf("%d ", p->data);  
88.         p = p->next;  
89.     }  
90. }  
91.   
92.   
93.   
94.   
95. void move(STACK &Sa,STACK &Sb)  
96. {     
97.     ElemType e;  
98.     Pop(Sa,&e);  
99.     Push(Sb, e);  
100. }  
101. void hanoi(int n,STACK  &X,STACK &Y,STACK &Z)  
102. {  
103.     if(n==1) return move(X, Z);     //将圆盘1号直接移到z  
104.     hanoi(n-1,X,Z,Y);               //将x上的1大n-1圆盘移到y，z做辅助塔  
105.     move(X, Z);                     //将编号为n的圆盘移z  
106.     hanoi(n-1,Y,X,Z);               //将y上的1大n-1圆盘移到z，x做辅助塔  
107. }  
108.   
109.   
110.   
111.   
112. int StackEmpty(STACK S)   
113. {  
114.     if(S.top==NULL) return TRUE;  
115.     return   FALSE;  
116. }  
117.   
118. void main()    
119. {    
120.   
121.     STACK Sx, Sy,Sz;  
122.     InitStack( Sx);  
123.     InitStack( Sy);  
124.     InitStack( Sz);  
125.     int i, n = 10;  
126.     for (i = 10 ; i>=1 ;i--) {  
127.         Push(Sx, i);  
128.     }  
129.     printStack(Sx);  
130.     hanoi(n,  Sx,Sy,Sz);  
131.     printStack(Sz);  
132. }    

 

 

复制去Google翻译 翻译结果