栈的链式结构

转自：http://blog.csdn.net/youlezhe/article/details/50564677?locationNum=2&fps=1

1.                 /* 2 栈的链式结构实现 */  
2.   
3. #include <stdio.h>  
4. #include <stdbool.h>  
5. #include <stdlib.h>  
6.   
7. typedef int TYPE;//元素类型别名  
8.   
9. //声明顺序栈结构体  
10. typedef struct stack  
11. {  
12.     TYPE data;//存储结点数据  
13.     struct stack* next;//记录后继结点的地址  
14. }stack;  
15.   
16. void init(stack**);//初始化  
17.   
18. void push(stack**,TYPE);//入栈  
19.   
20. TYPE pop(stack**);//出栈  
21.   
22. void clear(stack**);//清空  
23.   
24. bool isEmpty(stack*);//判断栈是否已满  
25.   
26. int length(stack*);//返回栈的元素个数  
27.   
28. void ergodic(stack*);//遍历栈中元素  
29.   
30. int search(stack*,TYPE);//搜索，返回具栈顶首次出现位置  
31.   
32. int main()  
33. {  
34.     stack* top;  
35.     init(&top);  
36.   
37.     //入栈测试  
38.     int count=0;//记录入栈元素个数  
39.     printf("输入入栈元素个数:");  
40.     scanf("%d",&count);  
41.     int elem;//记录单个入栈元素  
42.     printf("输入%d个元素：",count);  
43.     while(count)  
44.     {  
45.         scanf("%d",&elem);  
46.         push(&top,elem);  
47.         count--;  
48.     }  
49.   
50.     //遍历测试  
51.     printf("遍历栈中元素：");  
52.     ergodic(top);  
53.   
54.     scanf("%*[^\n]");  
55.     scanf("%*c");  
56.   
57.     //搜索测试  
58.     printf("输入要搜索的元素：");  
59.     scanf("%d",&elem);  
60.     int pos =search(top,elem);  
61.     if(pos)  
62.     {  
63.         printf("查找成功，%d在从栈顶开始第%d个元素\n",elem,pos);  
64.     }  
65.     else  
66.         printf("查找失败!\n");  
67.   
68.     //栈长度测试  
69.     count = length(top);  
70.       
71.     //栈清空测试  栈清空测试与出栈测试不能同时进行  
72.     //clear(&top);  
73.       
74.     //出栈测试  
75.     printf("栈中有%d个元素\n",count);  
76.     while(count--)  
77.         printf("出栈元素是：%d\n",pop(&top));  
78.       
79.     //栈长度测试  
80.     printf("栈中有%d个元素\n",length(top));  
81.   
82.     return 0;  
83. }  
84.   
85. //栈初始化  
86. //因为要更新栈顶指针本身的值，所以要用二级指针  
87. void init(stack** ss)  
88. {  
89.     *ss=NULL;  
90. }  
91.   
92. //入栈操作  
93. //因为要更新栈顶指针本身的值，所以要用二级指针  
94. void push(stack** ss,TYPE e)  
95. {  
96.     stack* p=(stack*)malloc(sizeof(struct stack));  
97.     if(p)  
98.     {  
99.         p->data = e;  
100.         p->next=*ss;  
101.         *ss=p;  
102.     }  
103.     else  
104.         printf("内存申请失败，缓冲区将清空！\n");  
105. }  
106.   
107. //出栈操作  
108. //因为要更新栈顶指针本身的值，所以用二级指针  
109. TYPE pop(stack** ss)  
110. {  
111.     if(!isEmpty(*ss))//栈不为空  
112.     {  
113.         stack* q=*ss;//记录原来的栈顶指针  
114.         int data=q->data;//获取栈顶元素值  
115.         *ss=(*ss)->next;//更新栈顶指针  
116.         free(q);//销毁原来栈顶元素  
117.         q=NULL;  
118.         return data;  
119.     }  
120. }  
121.   
122.   
123. //判断是否为空  
124. bool isEmpty(stack* s)  
125. {  
126.     return s==NULL;  
127. }  
128.   
129. //返回栈的长度  
130. int length(stack* s)  
131. {  
132.     int count=0;  
133.     while(s)  
134.     {  
135.         s = s->next;  
136.         count++;  
137.     }  
138.     return count;  
139. }  
140.   
141.   
142. //遍历栈  
143. void ergodic(stack* s)  
144. {  
145.     while(s)  
146.     {  
147.         printf("%d ",s->data);  
148.         s=s->next;  
149.     }  
150.         printf("\n");  
151. }  
152.   
153. //搜索栈中元素  
154. //返回元素距离栈顶的位置,如果有多个相同值，则返回首次出现的位置  
155. int search(stack* s,TYPE e)  
156. {  
157.     int pos=0;  
158.     while(s)  
159.     {  
160.         if(s->data==e)  
161.         {  
162.             pos++;  
163.             break;//找到就停止继续寻找  
164.         }  
165.             pos++;  
166.             s=s->next;  
167.     }  
168.     return pos;  
169. }  
170.   
171. //清空栈  
172. //因为要更新栈顶指针本身的值，所以要用二级指针  
173. void clear(stack** ss)  
174. {  
175.     while(*ss)  
176.     {  
177.         stack* q=*ss;  
178.         *ss = (*ss)->next;  
179.         free(q);  
180.         q=NULL;  
181.     }  
182. }