第六篇：基本数据结构——栈的链式表示

以下为操作栈的算法，该栈为动态栈。

在该栈中，pTop指向的节点中存放该栈的栈顶数据,pBottom指向的节点的上一个节点存放该栈的栈底数据，pBottom指向的节点中不存放有效数据，这样做的目的是为了在进行入栈和出栈时方便对栈的操作，而不用考虑特殊情况

操作系统：ubuntu

编译软件：gcc

结果截图：

源代码：

[cpp] view plain copy

1. #include  
2. #include  
3. #include  
4.   
5.   
6. typedef struct Node  
7. {  
8. int data;  
9. struct Node *pNext;  
10. }NODE,*PNODE;  
11.   
12.   
13. typedef struct Stack  
14. {  
15. PNODE pTop;  
16. PNODE pBottom;  
17. }STACK,*PSTACK;  
18.   
19.   
20. PSTACK create_stack();  
21. void push_stack(PSTACK,int);  
22. void traverse_stack(PSTACK);  
23. bool pop_stack(PSTACK,int *);  
24. bool is_empty(PSTACK);  
25. void clear_stack(PSTACK);  
26.   
27.   
28. int main()  
29. {  
30. int data_pop;  
31. //创建一个空的栈，pS指针指向该栈  
32. PSTACK pS = create_stack();  
33.   
34.   
35. //向该栈中压入数据，遍历该栈并输出栈中的数据  
36. push_stack(pS,2);  
37. push_stack(pS,6);  
38. push_stack(pS,28);  
39. traverse_stack(pS);  
40.   
41.   
42. //从该栈中推出数据，遍历该栈并输出栈中的数据  
43. if(pop_stack(pS,&data_pop))  
44.   printf("pop succeed,the data poped out is:%d\n",data_pop);  
45. else   
46.       printf("pop failed\n");  
47. traverse_stack(pS);  
48. //清空栈，遍历该栈并输出栈中的数据  
49. clear_stack(pS);  
50. printf("data cleared!\n");  
51. traverse_stack(pS);  
52.   
53.   
54. return 0;  
55. }  
56.   
57.   
58.   
59.   
60. //创建一个空栈,并返回指向该栈的指针  
61.   
62.   
63. PSTACK create_stack()  
64. {  
65. PSTACK pS = (PSTACK)malloc(sizeof(STACK));  
66. pS->pTop = (PNODE)malloc(sizeof(NODE));  
67. if(NULL==pS || NULL==pS->pTop)  
68. {  
69.   printf("malloc failed");  
70.   exit(-1);  
71. }  
72. else  
73. {  
74.   pS->pBottom = pS->pTop;  
75.   pS->pBottom->pNext = NULL;  
76. }  
77. return pS;  
78. }  
79.   
80.   
81. //判断该栈是否为空  
82.   
83.   
84. bool is_empty(PSTACK pS)  
85. {  
86. if(pS->pTop == pS->pBottom)  
87.   return true;  
88.     else  
89.   return false;  
90. }  
91.   
92.   
93. //向pS指针指向的栈中压入数据val  
94. void push_stack(PSTACK pS,int val)  
95. {  
96. PNODE pNew = (PNODE)malloc(sizeof(NODE));  
97. if(NULL==pNew)  
98. {  
99.   printf("malloc failed");  
100.   exit(-1);  
101. }  
102. else  
103. {  
104.   pNew->data = val;  
105.   pNew->pNext = pS->pTop;  
106.   pS->pTop = pNew;  
107. }  
108. return ;  
109. }  
110.   
111.   
112. //从栈中推出数据，并将推出的数据保存在pData指针所指向的位置  
113. bool pop_stack(PSTACK pS,int *pData)  
114. {  
115. if(is_empty(pS))  
116.   return false;  
117. else  
118. {  
119.   PNODE p = pS->pTop;  
120.   *pData = p->data;  
121.   pS->pTop = p->pNext;  
122.   free(p);  
123.   p = NULL;  
124.   return true;  
125. }  
126. }  
127.   
128.   
129. //遍历栈，并自栈顶向栈底输出栈中的数据  
130. void traverse_stack(PSTACK pS)  
131. {  
132. PNODE pCurrent = pS->pTop;   
133. printf("Now datas int the stack are:\n");  
134. while(pCurrent != pS->pBottom)  
135.         {  
136.   printf("%d ",pCurrent->data);  
137.   pCurrent = pCurrent->pNext;  
138. }  
139. printf("\n");  
140. return ;  
141. }  
142.   
143.   
144. //清空栈，即将其还原为空栈  
145. void clear_stack(PSTACK pS)  
146. {  
147. if(is_empty(pS))  
148.   return ;  
149. else  
150. {  
151.   PNODE p = pS->pTop;  
152.   PNODE r = NULL;  
153.   while(p != pS->pBottom)  
154.   {  
155.     r = p->pNext;  
156. free(p);  
157. p = r;  
158.   }  
159.   pS->pTop = pS->pBottom;  
160.     }  
161. }