devbox
神奇cpp
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

顺序栈的详解_入栈和出栈的顺序规律

作者：神奇cpp | 2024-06-20 12:38:58

赞

踩

入栈和出栈的顺序规律

一、栈的定义

1.1 栈的定义

栈是一种特殊的数据结构，它的特点是后进先出（Last In First Out，LIFO）。栈是一种线性结构，它可以用来存储一组具有相同类型的数据元素。栈的基本操作包括压入（push）和弹出（pop），其中压入操作将数据元素添加到栈的顶部，弹出操作将栈顶的数据元素移除并返回。

1.2 栈的特点

栈的特点包括：

  1. 后进先出：栈中最后一个添加的元素最先被弹出。

  2. 只能在栈顶进行操作：栈的操作只能在栈顶进行，不能在中间或底部操作，因为栈是一种先进后出的结构。

  3. 可以用数组或链表实现：栈可以用数组或链表来实现，数组实现的栈需要指定栈的大小，而链表实现的栈可以动态扩展。

  4. 存储空间受限：栈的存储空间是有限的，一旦达到栈的存储上限，就会出现栈溢出的问题。

  5. 可以用递归实现：栈也可以通过递归的方式来实现，每次递归函数调用都会将参数和返回地址压入栈中，直到递归结束，最后按照相反的顺序弹出栈中的元素。

二、栈的实现使用与应用

2.1 栈的接口定义

  1. typedef int DataType;
  2.  
  3.  
  4. typedef struct
  5. {
  6. 	DataType *data; /* 堆空间 */
  7. 	int maxsize;
  8. 	int top;		/* 栈顶指针 */
  9. }SeqStack;
  10.  
  11.  
  12. /* 1. 初始化 */
  13. int init(SeqStack *S, int MaxSize);
  14.  
  15. /* 2. 进（入）栈 */
  16. int push(SeqStack *S, DataType x);
  17.  
  18. /* 3. 出栈 */
  19. int pop(SeqStack *S, DataType *x);
  20.  
  21. /* 4. 取栈顶元素 */
  22. int get_top(SeqStack *S, DataType *x);
  23.  
  24. /* 5. 栈为空？*/
  25. int empty(SeqStack *S);
  26.  
  27. /* 6. 栈满？*/
  28. int full(SeqStack *S);
  29.  
  30. /* 7. 销毁*/
  31. int destroy(SeqStack *S);

2.2 栈的实现

2.2.1  栈的初始化
  1. int init(SeqStack *S, int MaxSize)
  2. {
  3. 	/*申请内存空间*/
  4. 	S->data = (DataType*)malloc(sizeof(DataType)*MaxSize);
  5.  
  6. 	if(!S->data)
  7. 	{
  8. 		printf("内存申请错误，初始化失败！[10001]\n");
  9. 		return 10001;
  10. 	}
  11. 	S->maxsize = MaxSize;
  12. 	S->top = -1;
  13. 	return 0;
  14. }
2.2.2  入栈
  1. int push(SeqStack *S, DataType x)
  2. {
  3. 	/*是否满？*/
  4. 	if(full(S))
  5. 	{
  6. 		printf("栈已满！10002\n");
  7. 		return 10002;
  8. 	}
  9.  
  10. 	S->top++;			/*移动指针*/
  11. 	S->data[S->top] = x;/*放入数据*/
  12. 	return 0; /*OK*/
  13. }
2.2.3  出栈
  1. int pop(SeqStack *S, DataType *x)
  2. {
  3. 	/*是否空？*/
  4. 	if(empty(S))
  5. 	{
  6. 		printf("栈为空！10003\n");
  7. 		return 10003;
  8. 	}
  9.  
  10. 	*x = S->data[S->top];	/*栈顶元素赋值给x*/
  11. 	S->top--;				/*移动栈顶指针*/	
  12.  
  13. 	return 0;
  14. }
2.2.4  查找栈顶元素
  1. int get_top(SeqStack *S, DataType *x)
  2. {
  3. 	/*是否空？*/
  4. 	if(empty(S))
  5. 	{
  6. 		printf("栈为空！10003\n");
  7. 		return 10003;
  8. 	}
  9.  
  10. 	*x = S->data[S->top];	/*栈顶元素赋值给x*/
  11.  
  12. 	return 0;
  13. }
2.2.5  判断栈是否为空
  1. int empty(SeqStack *S)
  2. {
  3. 	return (S->top == -1)?1:0;
  4. }
2.2.6  判断栈是否已满
  1. int full(SeqStack *S)
  2. {
  3. 	return (S->top == S->maxsize - 1)?1:0;
  4. }
2.2.7  销毁栈
  1. int destroy(SeqStack *S)
  2. {
  3. 	free(S->data);
  4. 	return 0;
  5. }

2.3栈的应用

2.3.1十进制转二进制
  1. int d_to_b(int d)
  2. {
  3. 	SeqStack S;
  4. 	int b;
  5.  
  6. 	/*初始化栈*/
  7. 	init(&S,32);
  8.  
  9. 	/*d不为0，余数进栈*/
  10. 	while(d)
  11. 	{
  12. 		push(&S, d % 2);
  13. 		d /= 2;
  14. 	}
  15. 	
  16. 	/*依次出栈*/
  17. 	while(!empty(&S))
  18. 	{
  19. 		pop(&S,&b);
  20. 		printf("%d", b);
  21. 	}
  22.  
  23. 	/*销毁栈*/
  24. 	destroy(&S);
  25. }
2.3.2后缀表达式计算
  1. int expression()
  2. {
  3. 	SeqStack S;
  4. 	int i;
  5. 	int op1, op2;	
  6. 	int x;
  7.  
  8. 	char exp[20]; /*后缀表达式*/
  9.  
  10. 	init(&S, 10);
  11.  
  12. 	printf("请输入一个后缀表达式(eg. 56+):");
  13. 	scanf("%s", exp);
  14. 	for(i=0;i<strlen(exp);i++)
  15. 	{
  16. 		switch(exp[i])
  17. 		{
  18. 		case '0':
  19. 		case '1':
  20. 		case '2':
  21. 		case '3':
  22. 		case '4':
  23. 		case '5':
  24. 		case '6':
  25. 		case '7':
  26. 		case '8':
  27. 		case '9':
  28. 			/*入栈*/
  29. 			push(&S, exp[i]-48);
  30. 			printf("%c\n",exp[i]);
  31. 			break;
  32. 		case '+':
  33. 			/*出2个*/
  34. 			pop(&S, &op1);
  35. 			pop(&S, &op2);
  36. 			x = op1 + op2;
  37. 			push(&S, x);
  38. 			break;
  39.  
  40. 		case '*':
  41. 			pop(&S, &op1);
  42. 			pop(&S, &op2);
  43. 			x = op1 * op2;
  44. 			push(&S, x);
  45. 			break;
  46. 		case '-':
  47. 			pop(&S, &op1);
  48. 			pop(&S, &op2);
  49. 			x =  op2- op1;
  50. 			push(&S, x);
  51. 			break;
  52. 		case '/':
  53. 			pop(&S, &op1);
  54. 			pop(&S, &op2);
  55. 			x =  op2/op1;
  56. 			push(&S, x);
  57. 			break;	
  58. 		}
  59. 	}
  60. 	pop(&S, &x);
  61. 	printf("计算结果为：%s = %d\n", exp, x);
  62. 	destroy(&S);
  63. }

2.4栈的使用

  1. #include <stdio.h>
  2. #include "seqstack.h"
  3. #include "welcome.h"
  4.  
  5.  
  6. int main(int argc, char* argv[])
  7. {
  8. 	SeqStack S;
  9. 	DataType x;
  10. 	int maxsize;
  11. 	char yn;
  12. 	int i,m,n,cmd,d;
  13. ;
  14. 	for(i=0;i<strlen(welcome);i++)
  15. 	{
  16. 		printf("%c",welcome[i]);
  17. 		for(m=0;m<1000;m++)
  18. 			for(n=0;n<1000;n++)
  19. 			{
  20. 				;
  21. 			}
  22. 	}
  23. 	
  24. 		printf("---------顺序栈演示程序-----------\n");
  25. 	do
  26. 	{
  27. 		printf(" 1. 初始化\n");
  28. 		printf(" 2. 入栈\n");
  29. 		printf(" 3. 出栈\n");
  30. 		printf(" 4. 查找栈顶元素\n");
  31. 		printf(" 5. 判断栈为是否空\n");
  32. 		printf(" 6. 判断栈为是否满\n"); 
  33. 		printf(" 7. 销毁栈\n"); 
  34. 		printf(" 8. 栈的应用\n");
  35. 		printf(" 9. 帮助\n");
  36. 		printf("请选择（0~9,0退出)：");
  37. 		scanf("%d", &cmd);
  38. 		switch(cmd)
  39. 		{
  40. 		case 1:
  41. 			printf("请输入栈的最大存储空间(MaxSize)：");
  42. 			scanf("%d", &maxsize);
  43. 			if(!init(&S, maxsize))
  44. 			{
  45. 				printf("栈已初始化！\n");
  46. 			}
  47. 			break;
  48. 		case 2:
  49. 			printf("请输入入栈元素：x=");
  50. 			scanf("%d", &x);
  51. 			if(!push(&S, x))
  52. 			{
  53. 				printf("元素【%d】已入栈！\n", x);
  54.  
  55. 			}
  56. 			break;
  57. 		case 3:
  58. 			printf("确定要出栈（出栈后数据不可恢复,y|n,n）？");
  59. 			fflush(stdin);
  60. 			scanf("%c", &yn);
  61. 			if(yn == 'y' || yn == 'Y')
  62. 			{
  63. 				if(!pop(&S, &x))
  64. 				{
  65. 					printf("栈顶元素【%d】已出栈！\n", x);
  66. 				}
  67. 			}
  68.  
  69. 			break;
  70. 		case 4:
  71. 			if(!get_top(&S,&x)){
  72. 				printf("查找到栈顶元素[%d]\n",x); 
  73. 			}
  74. 			break; 
  75. 		case 5:
  76. 			if(empty(&S)){
  77. 				printf("栈为空！\n"); 
  78. 			}else{
  79. 				printf("栈内存在元素\n"); 
  80. 			}
  81. 			break;
  82. 		case 6:
  83. 			if(full(&S)){
  84. 				printf("栈满！\n"); 
  85. 			}else{
  86. 				printf("栈未满\n"); 
  87. 			}
  88. 			break;
  89. 		case 7:
  90. 			destroy(&S);
  91. 			printf("栈已销毁\n"); 	
  92. 			break;
  93. 		case 8:
  94. 			do
  95. 			{
  96. 				printf("----------8.栈的应用------------\n");
  97. 				printf(" 1. 十进制转换为二进制\n");
  98. 				printf(" 2. 后缀表达式计算\n");			
  99. 				printf(" 0. 返回\n");
  100. 				printf("请选择：");
  101. 				scanf("%d", &cmd);
  102.  
  103. 				if(cmd == 1)
  104. 				{
  105. 					printf("请输入一个十进制数：");
  106. 					scanf("%d", &d);
  107. 					printf("二进制为：");
  108. 					d_to_b(d);
  109. 					printf("\n");
  110. 				}
  111.  
  112. 				if(cmd == 2)
  113. 				{
  114. 					expression();
  115. 				}
  116. 			}while(cmd!=0);
  117. 			cmd = -1;
  118. 			break;
  119. 		case 9:
  120. 			printf(" 本程序为栈的演示程序，由黄彬森设计开发，程序完成了栈的基本功能！\n");		
  121. 		default:
  122. 			printf("输入选项不存在\n"); 		
  123. 		}
  124.  
  125. 	}while(cmd!=0);
  126.  
  127. 	return 0;
  128. }
  129. /*十进制转换为二进制*/
  130. int d_to_b(int d)
  131. {
  132. 	SeqStack S;
  133. 	int b;
  134.  
  135. 	/*初始化栈*/
  136. 	init(&S,32);
  137.  
  138. 	/*d不为0，余数进栈*/
  139. 	while(d)
  140. 	{
  141. 		push(&S, d % 2);
  142. 		d /= 2;
  143. 	}
  144. 	
  145. 	/*依次出栈*/
  146. 	while(!empty(&S))
  147. 	{
  148. 		pop(&S,&b);
  149. 		printf("%d", b);
  150. 	}
  151.  
  152. 	/*销毁栈*/
  153. 	destroy(&S);
  154. }
  155.  
  156.  
  157. /*后缀表达式计算*/
  158. int expression()
  159. {
  160. 	SeqStack S;
  161. 	int i;
  162. 	int op1, op2;	
  163. 	int x;
  164.  
  165. 	char exp[20]; /*后缀表达式*/
  166.  
  167. 	init(&S, 10);
  168.  
  169. 	printf("请输入一个后缀表达式(eg. 56+):");
  170. 	scanf("%s", exp);
  171. 	for(i=0;i<strlen(exp);i++)
  172. 	{
  173. 		switch(exp[i])
  174. 		{
  175. 		case '0':
  176. 		case '1':
  177. 		case '2':
  178. 		case '3':
  179. 		case '4':
  180. 		case '5':
  181. 		case '6':
  182. 		case '7':
  183. 		case '8':
  184. 		case '9':
  185. 			/*入栈*/
  186. 			push(&S, exp[i]-48);
  187. 			printf("%c\n",exp[i]);
  188. 			break;
  189. 		case '+':
  190. 			/*出2个*/
  191. 			pop(&S, &op1);
  192. 			pop(&S, &op2);
  193. 			x = op1 + op2;
  194. 			push(&S, x);
  195. 			break;
  196.  
  197. 		case '*':
  198. 			pop(&S, &op1);
  199. 			pop(&S, &op2);
  200. 			x = op1 * op2;
  201. 			push(&S, x);
  202. 			break;
  203. 		case '-':
  204. 			pop(&S, &op1);
  205. 			pop(&S, &op2);
  206. 			x =  op2- op1;
  207. 			push(&S, x);
  208. 			break;
  209. 		case '/':
  210. 			pop(&S, &op1);
  211. 			pop(&S, &op2);
  212. 			x =  op2/op1;
  213. 			push(&S, x);
  214. 			break;	
  215. 		}
  216. 	}
  217. 	pop(&S, &x);
  218. 	printf("计算结果为：%s = %d\n", exp, x);
  219. 	destroy(&S);
  220. }

三、完整代码

3.1  main.c文件代码

  1. #include <stdio.h>
  2. #include "seqstack.h"
  3. #include "welcome.h"
  4.  
  5.  
  6. int main(int argc, char* argv[])
  7. {
  8. 	SeqStack S;
  9. 	DataType x;
  10. 	int maxsize;
  11. 	char yn;
  12. 	int i,m,n,cmd,d;
  13. ;
  14. 	for(i=0;i<strlen(welcome);i++)
  15. 	{
  16. 		printf("%c",welcome[i]);
  17. 		for(m=0;m<1000;m++)
  18. 			for(n=0;n<1000;n++)
  19. 			{
  20. 				;
  21. 			}
  22. 	}
  23. 	
  24. 		printf("---------顺序栈演示程序-----------\n");
  25. 	do
  26. 	{
  27. 		printf(" 1. 初始化\n");
  28. 		printf(" 2. 入栈\n");
  29. 		printf(" 3. 出栈\n");
  30. 		printf(" 4. 查找栈顶元素\n");
  31. 		printf(" 5. 判断栈为是否空\n");
  32. 		printf(" 6. 判断栈为是否满\n"); 
  33. 		printf(" 7. 销毁栈\n"); 
  34. 		printf(" 8. 栈的应用\n");
  35. 		printf(" 9. 帮助\n");
  36. 		printf("请选择（0~9,0退出)：");
  37. 		scanf("%d", &cmd);
  38. 		switch(cmd)
  39. 		{
  40. 		case 1:
  41. 			printf("请输入栈的最大存储空间(MaxSize)：");
  42. 			scanf("%d", &maxsize);
  43. 			if(!init(&S, maxsize))
  44. 			{
  45. 				printf("栈已初始化！\n");
  46. 			}
  47. 			break;
  48. 		case 2:
  49. 			printf("请输入入栈元素：x=");
  50. 			scanf("%d", &x);
  51. 			if(!push(&S, x))
  52. 			{
  53. 				printf("元素【%d】已入栈！\n", x);
  54.  
  55. 			}
  56. 			break;
  57. 		case 3:
  58. 			printf("确定要出栈（出栈后数据不可恢复,y|n,n）？");
  59. 			fflush(stdin);
  60. 			scanf("%c", &yn);
  61. 			if(yn == 'y' || yn == 'Y')
  62. 			{
  63. 				if(!pop(&S, &x))
  64. 				{
  65. 					printf("栈顶元素【%d】已出栈！\n", x);
  66. 				}
  67. 			}
  68.  
  69. 			break;
  70. 		case 4:
  71. 			if(!get_top(&S,&x)){
  72. 				printf("查找到栈顶元素[%d]\n",x); 
  73. 			}
  74. 			break; 
  75. 		case 5:
  76. 			if(empty(&S)){
  77. 				printf("栈为空！\n"); 
  78. 			}else{
  79. 				printf("栈内存在元素\n"); 
  80. 			}
  81. 			break;
  82. 		case 6:
  83. 			if(full(&S)){
  84. 				printf("栈满！\n"); 
  85. 			}else{
  86. 				printf("栈未满\n"); 
  87. 			}
  88. 			break;
  89. 		case 7:
  90. 			destroy(&S);
  91. 			printf("栈已销毁\n"); 	
  92. 			break;
  93. 		case 8:
  94. 			do
  95. 			{
  96. 				printf("----------8.栈的应用------------\n");
  97. 				printf(" 1. 十进制转换为二进制\n");
  98. 				printf(" 2. 后缀表达式计算\n");			
  99. 				printf(" 0. 返回\n");
  100. 				printf("请选择：");
  101. 				scanf("%d", &cmd);
  102.  
  103. 				if(cmd == 1)
  104. 				{
  105. 					printf("请输入一个十进制数：");
  106. 					scanf("%d", &d);
  107. 					printf("二进制为：");
  108. 					d_to_b(d);
  109. 					printf("\n");
  110. 				}
  111.  
  112. 				if(cmd == 2)
  113. 				{
  114. 					expression();
  115. 				}
  116. 			}while(cmd!=0);
  117. 			cmd = -1;
  118. 			break;
  119. 		case 9:
  120. 			printf(" 本程序为栈的演示程序，由黄彬森设计开发，程序完成了栈的基本功能！\n");		
  121. 		default:
  122. 			printf("输入选项不存在\n"); 		
  123. 		}
  124.  
  125. 	}while(cmd!=0);
  126.  
  127. 	return 0;
  128. }
  129. /*十进制转换为二进制*/
  130. int d_to_b(int d)
  131. {
  132. 	SeqStack S;
  133. 	int b;
  134.  
  135. 	/*初始化栈*/
  136. 	init(&S,32);
  137.  
  138. 	/*d不为0，余数进栈*/
  139. 	while(d)
  140. 	{
  141. 		push(&S, d % 2);
  142. 		d /= 2;
  143. 	}
  144. 	
  145. 	/*依次出栈*/
  146. 	while(!empty(&S))
  147. 	{
  148. 		pop(&S,&b);
  149. 		printf("%d", b);
  150. 	}
  151.  
  152. 	/*销毁栈*/
  153. 	destroy(&S);
  154. }
  155.  
  156.  
  157. /*后缀表达式计算*/
  158. int expression()
  159. {
  160. 	SeqStack S;
  161. 	int i;
  162. 	int op1, op2;	
  163. 	int x;
  164.  
  165. 	char exp[20]; /*后缀表达式*/
  166.  
  167. 	init(&S, 10);
  168.  
  169. 	printf("请输入一个后缀表达式(eg. 56+):");
  170. 	scanf("%s", exp);
  171. 	for(i=0;i<strlen(exp);i++)
  172. 	{
  173. 		switch(exp[i])
  174. 		{
  175. 		case '0':
  176. 		case '1':
  177. 		case '2':
  178. 		case '3':
  179. 		case '4':
  180. 		case '5':
  181. 		case '6':
  182. 		case '7':
  183. 		case '8':
  184. 		case '9':
  185. 			/*入栈*/
  186. 			push(&S, exp[i]-48);
  187. 			printf("%c\n",exp[i]);
  188. 			break;
  189. 		case '+':
  190. 			/*出2个*/
  191. 			pop(&S, &op1);
  192. 			pop(&S, &op2);
  193. 			x = op1 + op2;
  194. 			push(&S, x);
  195. 			break;
  196.  
  197. 		case '*':
  198. 			pop(&S, &op1);
  199. 			pop(&S, &op2);
  200. 			x = op1 * op2;
  201. 			push(&S, x);
  202. 			break;
  203. 		case '-':
  204. 			pop(&S, &op1);
  205. 			pop(&S, &op2);
  206. 			x =  op2- op1;
  207. 			push(&S, x);
  208. 			break;
  209. 		case '/':
  210. 			pop(&S, &op1);
  211. 			pop(&S, &op2);
  212. 			x =  op2/op1;
  213. 			push(&S, x);
  214. 			break;	
  215. 		}
  216. 	}
  217. 	pop(&S, &x);
  218. 	printf("计算结果为：%s = %d\n", exp, x);
  219. 	destroy(&S);
  220. }

3.2  seqstack.h文件代码

  1. typedef int DataType;
  2.  
  3.  
  4. typedef struct
  5. {
  6. 	DataType *data; /* 堆空间 */
  7. 	int maxsize;
  8. 	int top;		/* 栈顶指针 */
  9. }SeqStack;
  10.  
  11.  
  12. /* 1. 初始化 */
  13. int init(SeqStack *S, int MaxSize);
  14.  
  15. /* 2. 进（入）栈 */
  16. int push(SeqStack *S, DataType x);
  17.  
  18. /* 3. 出栈 */
  19. int pop(SeqStack *S, DataType *x);
  20.  
  21. /* 4. 取栈顶元素 */
  22. int get_top(SeqStack *S, DataType *x);
  23.  
  24. /* 5. 栈为空？*/
  25. int empty(SeqStack *S);
  26.  
  27. /* 6. 栈满？*/
  28. int full(SeqStack *S);
  29.  
  30. /* 7. 销毁*/
  31. int destroy(SeqStack *S);

3.3  seqstack.c文件代码

  1. #include "seqstack.h"
  2.  
  3.  
  4. /* 1. 初始化 */
  5. int init(SeqStack *S, int MaxSize)
  6. {
  7. 	/*申请内存空间*/
  8. 	S->data = (DataType*)malloc(sizeof(DataType)*MaxSize);
  9.  
  10. 	if(!S->data)
  11. 	{
  12. 		printf("内存申请错误，初始化失败！[10001]\n");
  13. 		return 10001;
  14. 	}
  15. 	S->maxsize = MaxSize;
  16. 	S->top = -1;
  17. 	return 0;
  18. }
  19.  
  20.  
  21. /* 2. 进（入）栈 */
  22. int push(SeqStack *S, DataType x)
  23. {
  24. 	/*是否满？*/
  25. 	if(full(S))
  26. 	{
  27. 		printf("栈已满！10002\n");
  28. 		return 10002;
  29. 	}
  30.  
  31. 	S->top++;			/*移动指针*/
  32. 	S->data[S->top] = x;/*放入数据*/
  33. 	return 0; /*OK*/
  34. }
  35.  
  36. /* 3. 出栈 */
  37. int pop(SeqStack *S, DataType *x)
  38. {
  39. 	/*是否空？*/
  40. 	if(empty(S))
  41. 	{
  42. 		printf("栈为空！10003\n");
  43. 		return 10003;
  44. 	}
  45.  
  46. 	*x = S->data[S->top];	/*栈顶元素赋值给x*/
  47. 	S->top--;				/*移动栈顶指针*/	
  48.  
  49. 	return 0;
  50. }
  51.  
  52. /* 4. 取栈顶元素 */
  53. int get_top(SeqStack *S, DataType *x)
  54. {
  55. 	/*是否空？*/
  56. 	if(empty(S))
  57. 	{
  58. 		printf("栈为空！10003\n");
  59. 		return 10003;
  60. 	}
  61.  
  62. 	*x = S->data[S->top];	/*栈顶元素赋值给x*/
  63.  
  64. 	return 0;
  65. }
  66.  
  67. /* 5. 栈为空？*/
  68. int empty(SeqStack *S)
  69. {
  70. 	return (S->top == -1)?1:0;
  71. }
  72.  
  73. /* 6. 栈满？*/
  74. int full(SeqStack *S)
  75. {
  76. 	return (S->top == S->maxsize - 1)?1:0;
  77. }
  78.  
  79.  
  80. /* 7. 销毁*/
  81. int destroy(SeqStack *S)
  82. {
  83. 	free(S->data);
  84. 	return 0;
  85. }

3.4  welcome.h文件代码

  1. char welcome[] = "\n\
  2. |     .-.\n\ 
  3. |    /   、         .-.\n\
  4. |   /     、       /   、       .-.     .-.\n\
  5. +--/-------、-----/-----、-----/---、---/---、---/-、-/-、/、/---\n\
  6. | /         、   /       、   /     '-'     '-'              \n\
  7. |/           '-'         '-'                               \n\
  8. ";

四、代码运行结果

  1. |     .-.
  2. |    /   、         .-.
  3. |   /     、       /   、       .-.     .-.
  4. +--/-------、-----/-----、-----/---、---/---、---/-、-/-、/、/---
  5. | /         、   /       、   /     '-'     '-'
  6. |/           '-'         '-'
  7. ---------顺序栈演示程序-----------
  8.  1. 初始化
  9.  2. 入栈
  10.  3. 出栈
  11.  4. 查找栈顶元素
  12.  5. 判断栈为是否空
  13.  6. 判断栈为是否满
  14.  7. 销毁栈
  15.  8. 栈的应用
  16.  9. 帮助
  17. 请选择（0~9,0退出)：1
  18. 请输入栈的最大存储空间(MaxSize)：10
  19. 栈已初始化！
  20.  1. 初始化
  21.  2. 入栈
  22.  3. 出栈
  23.  4. 查找栈顶元素
  24.  5. 判断栈为是否空
  25.  6. 判断栈为是否满
  26.  7. 销毁栈
  27.  8. 栈的应用
  28.  9. 帮助
  29. 请选择（0~9,0退出)：2
  30. 请输入入栈元素：x=10
  31. 元素【10】已入栈！
  32.  1. 初始化
  33.  2. 入栈
  34.  3. 出栈
  35.  4. 查找栈顶元素
  36.  5. 判断栈为是否空
  37.  6. 判断栈为是否满
  38.  7. 销毁栈
  39.  8. 栈的应用
  40.  9. 帮助
  41. 请选择（0~9,0退出)：2
  42. 请输入入栈元素：x=30
  43. 元素【30】已入栈！
  44.  1. 初始化
  45.  2. 入栈
  46.  3. 出栈
  47.  4. 查找栈顶元素
  48.  5. 判断栈为是否空
  49.  6. 判断栈为是否满
  50.  7. 销毁栈
  51.  8. 栈的应用
  52.  9. 帮助
  53. 请选择（0~9,0退出)：4
  54. 查找到栈顶元素[30]
  55.  1. 初始化
  56.  2. 入栈
  57.  3. 出栈
  58.  4. 查找栈顶元素
  59.  5. 判断栈为是否空
  60.  6. 判断栈为是否满
  61.  7. 销毁栈
  62.  8. 栈的应用
  63.  9. 帮助
  64. 请选择（0~9,0退出)：5
  65. 栈内存在元素
  66.  1. 初始化
  67.  2. 入栈
  68.  3. 出栈
  69.  4. 查找栈顶元素
  70.  5. 判断栈为是否空
  71.  6. 判断栈为是否满
  72.  7. 销毁栈
  73.  8. 栈的应用
  74.  9. 帮助
  75. 请选择（0~9,0退出)：6
  76. 栈未满
  77.  1. 初始化
  78.  2. 入栈
  79.  3. 出栈
  80.  4. 查找栈顶元素
  81.  5. 判断栈为是否空
  82.  6. 判断栈为是否满
  83.  7. 销毁栈
  84.  8. 栈的应用
  85.  9. 帮助
  86. 请选择（0~9,0退出)：3
  87. 确定要出栈（出栈后数据不可恢复,y|n,n）？y
  88. 栈顶元素【30】已出栈！
  89.  1. 初始化
  90.  2. 入栈
  91.  3. 出栈
  92.  4. 查找栈顶元素
  93.  5. 判断栈为是否空
  94.  6. 判断栈为是否满
  95.  7. 销毁栈
  96.  8. 栈的应用
  97.  9. 帮助
  98. 请选择（0~9,0退出)：7
  99. 栈已销毁
  100.  1. 初始化
  101.  2. 入栈
  102.  3. 出栈
  103.  4. 查找栈顶元素
  104.  5. 判断栈为是否空
  105.  6. 判断栈为是否满
  106.  7. 销毁栈
  107.  8. 栈的应用
  108.  9. 帮助
  109. 请选择（0~9,0退出)：8
  110. ----------8.栈的应用------------
  111.  1. 十进制转换为二进制
  112.  2. 后缀表达式计算
  113.  0. 返回
  114. 请选择：1
  115. 请输入一个十进制数：102
  116. 二进制为：1100110
  117. ----------8.栈的应用------------
  118.  1. 十进制转换为二进制
  119.  2. 后缀表达式计算
  120.  0. 返回
  121. 请选择：2
  122. 请输入一个后缀表达式(eg. 56+):34+4-2*2/
  123. 3
  124. 4
  125. 4
  126. 2
  127. 2
  128. 计算结果为：34+4-2*2/ = 3
  129. ----------8.栈的应用------------
  130.  1. 十进制转换为二进制
  131.  2. 后缀表达式计算
  132.  0. 返回
  133. 请选择：0
  134.  1. 初始化
  135.  2. 入栈
  136.  3. 出栈
  137.  4. 查找栈顶元素
  138.  5. 判断栈为是否空
  139.  6. 判断栈为是否满
  140.  7. 销毁栈
  141.  8. 栈的应用
  142.  9. 帮助
  143. 请选择（0~9,0退出)：9
  144.  本程序为栈的演示程序，由黄彬森设计开发，程序完成了栈的基本功能！
  145. 输入选项不存在
  146.  1. 初始化
  147.  2. 入栈
  148.  3. 出栈
  149.  4. 查找栈顶元素
  150.  5. 判断栈为是否空
  151.  6. 判断栈为是否满
  152.  7. 销毁栈
  153.  8. 栈的应用
  154.  9. 帮助
  155. 请选择（0~9,0退出)：0
  156.  
  157. --------------------------------
  158. Process exited after 128.2 seconds with return value 0
  159. 请按任意键继续. . .

五、小结

栈是一种特殊的顺序结构，栈存储方式以先入后出，后入先出的原则存储数据。入栈时添加元素会置于栈的栈顶，出栈时也需元素从栈顶处出栈，栈可以通过数组和链表实现，链表实现相对简单些，并且链表可以动态扩展,。

六、参考文献

【1】CSDN

【2】数据结构(C语言)

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/神奇cpp/article/detail/739824
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号