数据结构实验3：栈子系统
栈的实验报告结论(3篇)
第1篇一、实验目的1. 理解栈的基本概念和操作；2. 掌握栈的顺序存储和链式存储实现方法；3. 熟悉栈在程序设计中的应用。
二、实验内容1. 栈的顺序存储结构实现；2. 栈的链式存储结构实现；3. 栈的基本操作（入栈、出栈、判空、求栈顶元素）；4. 栈在程序设计中的应用。
三、实验方法1. 采用C语言进行编程实现；2. 对实验内容进行逐步分析，编写相应的函数和程序代码；3. 通过运行程序验证实验结果。
四、实验步骤1. 实现栈的顺序存储结构；（1）定义栈的结构体；（2）编写初始化栈的函数；（3）编写入栈、出栈、判空、求栈顶元素的函数；（4）编写测试程序，验证顺序存储结构的栈操作。
2. 实现栈的链式存储结构；（1）定义栈的节点结构体；（2）编写初始化栈的函数；（3）编写入栈、出栈、判空、求栈顶元素的函数；（4）编写测试程序，验证链式存储结构的栈操作。
3. 栈在程序设计中的应用；（1）实现一个简单的四则运算器，使用栈进行运算符和操作数的存储；（2）实现一个逆序输出字符串的程序，使用栈进行字符的存储和输出；（3）编写测试程序，验证栈在程序设计中的应用。
五、实验结果与分析1. 顺序存储结构的栈操作实验结果：（1）入栈操作：在栈未满的情况下，入栈操作成功，栈顶元素增加；（2）出栈操作：在栈非空的情况下，出栈操作成功，栈顶元素减少；（3）判空操作：栈为空时，判空操作返回真，栈非空时返回假；（4）求栈顶元素操作：在栈非空的情况下，成功获取栈顶元素。
2. 链式存储结构的栈操作实验结果：（1）入栈操作：在栈未满的情况下，入栈操作成功，链表头指针指向新节点；（2）出栈操作：在栈非空的情况下，出栈操作成功，链表头指针指向下一个节点；（3）判空操作：栈为空时，判空操作返回真，栈非空时返回假；（4）求栈顶元素操作：在栈非空的情况下，成功获取栈顶元素。
3. 栈在程序设计中的应用实验结果：（1）四则运算器：成功实现加、减、乘、除运算，并输出结果；（2）逆序输出字符串：成功将字符串逆序输出；（3）测试程序：验证了栈在程序设计中的应用。
数据结构实验报告之栈和队列
数据结构实验报告之栈和队列1. 编写程序实现顺序栈的各种基本运算：初始化、销毁、清空、判断是否为空栈、求栈的长度、取栈顶元素、进栈、出栈。
在此基础上设计⼀个主程序完成如下功能：（1）初始化栈s；（2）判断栈s是否为空；（3）依次进栈元素a，b，c，d；（4）判断栈s是否为空；（5）输出栈s的长度；（6）栈⾥元素依次出栈,并输出；（7）销毁栈s。
#include<stdio.h>#include<malloc.h>#include<stdlib.h>#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int Status;typedef char SElemType;#define STACK_INIT_SIZE 100 //存储空间初始分配量#define STACKINCREMENT 10 //存储空间分配增量typedef struct {SElemType *base; //栈底指针SElemType *top; //栈顶指针int stacksize; //当前已分配的存储空间} SqStack;Status InitStack(SqStack &S) { //构造⼀个空栈SS.base = (SElemType*)malloc(STACK_INIT_SIZE * sizeof(SElemType));if (!S.base) exit(OVERFLOW);S.top = S.base;S.stacksize = STACK_INIT_SIZE;return OK;}//InitStackStatus StackLength(SqStack S) {return S.top - S.base;}//StackLengthStatus DestoryStack(SqStack &S) {S.top = S.base;free(S.base);//若base的值为NULL，则表明栈结构不存在S.base = NULL;S.top = NULL;S.stacksize = 0;return OK;}Status StackEmpty(SqStack S) {if (S.top == S.base)return1;elsereturn0;}//StackEmptyStatus GetTop(SqStack S, SElemType &e) {if (S.top == S.base) return ERROR;e = *(S.top - 1);return OK;}//GetTopStatus Push(SqStack &S, SElemType e) {if (S.top - S.base >= S.stacksize) {S.base = (SElemType*)realloc(S.base,(S.stacksize + STACKINCREMENT) * sizeof(SElemType));if (!S.base)exit(OVERFLOW);S.top = S.base + S.stacksize;S.stacksize+= STACKINCREMENT;}*S.top++=e;return OK;}//PushStatus Pop(SqStack &S, SElemType &e) {//判断栈是否为空if (S.base == S.top)return ERROR;e = *(S.top - 1);S.top--;return OK;}//Popvoid main(){SqStack s;SElemType e;printf("(1)初始化栈\n");InitStack(s);printf("(2)The stack is ");if (StackEmpty(s))printf("empty.\n");elseprintf("not empty.\n");printf("(3)依次进栈元素a，b，c，d\n");Push(s, 'a');Push(s, 'b');Push(s, 'c');Push(s, 'd');printf("(4)The stack is ");if (StackEmpty(s))printf("empty.\n");elseprintf("not empty.\n");printf("(5)The length of the stack is %d\n", StackLength(s));printf("(6)The stack is ");while (!StackEmpty(s)){Pop(s, e);printf("%c \n", e);}printf("(7)销毁栈s");DestoryStack(s);}运⾏结果：2. 编写程序实现链队列的各种基本运算：初始化、销毁、清空、判断是否为空队列、求队列的长度、取队列的头元素、⼊队、出队。
实验报告——栈和队列的应用
实验报告——栈和队列的应用第一篇：实验报告——栈和队列的应用实验5 栈和队列的应用目的和要求：（1）熟练栈和队列的基本操作；（2）能够利用栈与队列进行简单的应用。
一、题目题目1.利用顺序栈和队列，实现一个栈和一个队列，并利用其判断一个字符串是否是回文。
所谓回文，是指从前向后顺读和从后向前倒读都一样的字符串。
例如，a+b&b+a等等。
题目2.假设在周末舞会上，男士们和女士们进入舞厅时，各自排成一队。
跳舞开始时，依次从男队和女队的队头上各出一人配成舞伴。
若两队初始人数不相同，则较长的那一队中未配对者等待下一轮舞曲。
现要求写一算法模拟上述舞伴配对问题，并实现。
题目3.打印机提供的网络共享打印功能采用了缓冲池技术，队列就是实现这个缓冲技术的数据结构支持。
每台打印机具有一个队列（缓冲池），用户提交打印请求被写入到队列尾，当打印机空闲时，系统读取队列中第一个请求，打印并删除之。
请利用队列的先进先出特性，完成打印机网络共享的先来先服务功能。
题目4.假设以数组Q[m]存放循环队列中的元素, 同时设置一个标志tag，以tag == 0和tag == 1来区别在队头指针(front)和队尾指针(rear)相等时，队列状态为“空”还是“满”。
试编写与此结构相应的插入(enqueue)和删除(dlqueue)算法。
题目5.利用循环链队列求解约瑟夫环问题。
请大家从本组未讨论过的五道题中选择一道，参照清华邓俊辉老师MOOC视频及课本相关知识，编写相应程序。
选择题目3：打印机提供的网络共享打印功能采用了缓冲池技术，队列就是实现这个缓冲技术的数据结构支持。
二、程序清单//Ch3.cpp #include #include #include“ch3.h” template void LinkedQueue::makeEmpty()//makeEmpty//函数的实现{ LinkNode*p;while(front!=NULL)//逐个删除队列中的结点{p=front;front=front->link;delete p;} };template bool LinkedQueue::put_in(T&x）{//提交命令函数if(front==NULL){//判断是否为空front=rear=new LinkNode;//如果为空，新结点为对头也为对尾front->data=rear->data=x;if(front==NULL)//分配结点失败return false;} else{rear->link=new LinkNode;//如不为空，在链尾加新的结点rear->link->data=x;if(rear->link==NULL)return false;rear=rear->link;} return true;};template bool LinkedQueue::carry_out()//执行命令函数 { if(IsEmpty()==true)//判断是否为空{return false;} cout<data<LinkNode*p=front;front=front->link;//删除以执行的命令，即对头修改delete p;//释放原结点return true;};void main()//主函数 { LinkedQueue q;//定义类对象char flag='Y';//标志是否输入了命令const int max=30;//一次获取输入命令的最大个数while(flag=='Y')//循环{ int i=0;char str[max];//定义存储屏幕输入的命令的数组gets(str);//获取屏幕输入的命令while(str[i]!=''){q.put_in(str[i]);//调用提交命令函数，将每个命令存入队列中i++;}for(int j=0;j<=i;j++){if(q.IsEmpty()==true)//判断是否为空，为空则说明没有可执行的命令{cout<cin>>flag;continue;//为空跳出for循环为下次输入命令做好准备}q.carry_out();//调用执行命令的函数，将命令打印并删除}三、程序调试过程中所出现的错误无。
栈的基本操作实验报告
栈的基本操作实验报告实验目的本实验旨在通过使用栈来实现基本的操作，包括入栈、出栈、查看栈顶元素以及判断栈是否为空。
实验原理栈是一种后进先出（Last-In-First-Out）的数据结构，类似于我们平常生活中的堆栈。
栈有两个基本操作：入栈（Push）和出栈（Pop）。
•入栈：将一个元素放入栈的顶部，使其成为新的栈顶元素。
•出栈：移除栈顶元素，并返回该元素的值。
•查看栈顶元素：返回栈顶元素的值，但不将其从栈中移除。
•判断栈是否为空：若栈中没有元素，则栈为空。
实验步骤以下是使用Python语言来实现栈基本操作的步骤。
1. 创建一个空栈首先，我们需要创建一个空栈。
可以使用列表（List）来模拟栈的操作。
例如：stack = []2. 入栈操作接下来，我们可以通过使用append()函数将元素添加到栈的顶部来进行入栈操作。
例如，我们将数字1和2入栈：stack.append(1)stack.append(2)此时栈的内容为：[1, 2]，其中2为栈顶元素。
3. 出栈操作要进行出栈操作，我们可以使用pop()函数。
该函数会移除并返回栈顶元素的值。
例如：value = stack.pop()print(value) # 输出：2此时栈的内容为：[1]，其中1为新的栈顶元素。
4. 查看栈顶元素要查看栈顶元素的值，我们可以使用索引-1来访问栈的最后一个元素。
例如：value = stack[-1]print(value) # 输出：1此时栈的内容仍为：[1]，其中1为栈顶元素。
5. 判断栈是否为空要判断栈是否为空，我们可以使用条件语句结合len()函数来判断栈的长度是否为0。
例如：if len(stack) ==0:print("栈为空")else:print("栈不为空")由于栈中还有一个元素1，所以输出为“栈不为空”。
实验总结通过本实验，我们学习了栈的基本操作，包括入栈、出栈、查看栈顶元素以及判断栈是否为空。
栈实验报告实验结论
实验目的：1. 理解栈的基本概念和原理；2. 掌握栈的基本操作，如入栈、出栈、判空等；3. 通过实验加深对栈在实际问题中的应用理解。
实验环境：1. 操作系统：Windows 10；2. 编程语言：C++；3. 开发工具：Visual Studio 2019。
实验内容：1. 定义栈的数据结构；2. 实现栈的基本操作；3. 编写实验程序，测试栈的功能。
实验步骤：1. 定义栈的数据结构：使用数组来实现栈，定义栈的最大容量、栈顶指针和栈底指针。
2. 实现栈的基本操作：a. 初始化栈：将栈顶指针和栈底指针都指向栈的底部；b. 判断栈是否为空：如果栈顶指针等于栈底指针，则栈为空；c. 判断栈是否已满：如果栈顶指针等于栈的最大容量减1，则栈已满；d. 入栈：将元素添加到栈顶，如果栈未满，则栈顶指针加1；e. 出栈：从栈顶取出元素，如果栈不为空，则栈顶指针减1；f. 获取栈顶元素：如果栈不为空，则返回栈顶元素。
3. 编写实验程序，测试栈的功能。
实验结果：1. 初始化栈：创建一个最大容量为10的栈，栈顶指针和栈底指针都指向栈的底部。
2. 判断栈是否为空：当栈为空时，判断结果为真；当栈不为空时，判断结果为假。
3. 判断栈是否已满：当栈已满时，判断结果为真；当栈未满时，判断结果为假。
4. 入栈操作：成功将元素添加到栈顶，栈顶指针加1。
5. 出栈操作：成功从栈顶取出元素，栈顶指针减1。
6. 获取栈顶元素：成功获取栈顶元素。
实验结论：1. 通过本次实验，我们深入理解了栈的基本概念和原理，掌握了栈的基本操作，如入栈、出栈、判空等。
2. 实验结果表明，我们成功实现了栈的数据结构，并实现了栈的基本操作。
3. 在实际应用中，栈是一种常用的数据结构，可以用于解决许多问题，如括号匹配、表达式求值、函数调用等。
通过本次实验，我们对栈在实际问题中的应用有了更深入的理解。
4. 实验过程中，我们遇到了一些问题，如栈的初始化、栈的判空、栈的判满等。
数据结构实验报告_栈(3篇)
第1篇一、实验目的本次实验旨在通过实际操作，加深对栈这一数据结构的理解，掌握栈的基本操作，包括初始化、入栈、出栈、取栈顶元素、判栈空等。
同时，通过实验练习，提高编程能力和问题解决能力。
二、实验内容1. 栈的定义及特点2. 栈的顺序存储结构3. 栈的链式存储结构4. 栈的基本操作5. 栈的应用实例三、实验过程1. 栈的定义及特点栈是一种后进先出（LIFO）的数据结构，它只允许在一端进行插入和删除操作。
栈的顶元素总是最后被插入的元素，也是最先被删除的元素。
2. 栈的顺序存储结构顺序存储结构是使用数组来实现栈。
定义一个数组作为栈的存储空间，同时定义一个指针top来指示栈顶元素的位置。
3. 栈的链式存储结构链式存储结构是使用链表来实现栈。
定义一个节点结构体，其中包含数据和指向下一个节点的指针。
头节点作为栈顶元素。
4. 栈的基本操作（1）初始化：创建一个空栈，top指针指向栈底。
（2）入栈：将新元素插入到栈顶。
如果栈满，则进行扩容。
（3）出栈：删除栈顶元素，并将其返回。
如果栈空，则返回错误信息。
（4）取栈顶元素：返回栈顶元素的值，但不删除栈顶元素。
（5）判栈空：判断栈是否为空，如果为空，则返回true；否则，返回false。
5. 栈的应用实例（1）括号匹配检验：利用栈判断一个字符串中的括号是否匹配。
（2）算术表达式求值：利用栈实现算术表达式求值，包括四则运算和括号。
四、实验结果与分析1. 初始化栈初始化栈后，栈为空，top指针指向栈底。
2. 入栈操作将元素1、2、3依次入栈，栈的状态如下：```top -> 3 -> 2 -> 1```3. 出栈操作依次出栈元素，栈的状态如下：```top -> 2 -> 1```4. 取栈顶元素取栈顶元素2，栈的状态不变。
5. 判栈空当栈中只有一个元素时，判断栈为空，返回false。
6. 括号匹配检验对于字符串"((()))"，括号匹配检验结果为true；对于字符串"(()))"，括号匹配检验结果为false。
数据结构栈和队列实验报告
数据结构栈和队列实验报告一、实验目的本次实验的主要目的是深入理解和掌握数据结构中的栈和队列的基本概念、操作原理以及实际应用。
通过编程实现栈和队列的相关操作，加深对其特性的认识，并能够运用栈和队列解决实际问题。
二、实验环境本次实验使用的编程语言为C+＋，开发工具为Visual Studio 2019。
三、实验原理（一）栈栈（Stack）是一种特殊的线性表，其操作遵循“后进先出”（Last In First Out，LIFO）的原则。
可以将栈想象成一个只有一端开口的容器，元素只能从开口端进出。
入栈操作（Push）将元素添加到栈顶，出栈操作（Pop）则从栈顶移除元素。
（二）队列队列（Queue）也是一种线性表，但其操作遵循“先进先出”（FirstIn First Out，FIFO）的原则。
队列就像是排队买票的队伍，先到的人先接受服务。
入队操作（Enqueue）将元素添加到队列的末尾，出队操作（Dequeue）则从队列的头部移除元素。
四、实验内容（一）栈的实现与操作1、定义一个栈的数据结构，包含栈顶指针、存储元素的数组以及栈的最大容量等成员变量。
2、实现入栈（Push）操作，当栈未满时，将元素添加到栈顶，并更新栈顶指针。
3、实现出栈（Pop）操作，当栈不为空时，取出栈顶元素，并更新栈顶指针。
4、实现获取栈顶元素（Top）操作，返回栈顶元素但不进行出栈操作。
5、实现判断栈是否为空（IsEmpty）和判断栈是否已满（IsFull）的操作。
（二）队列的实现与操作1、定义一个队列的数据结构，包含队头指针、队尾指针、存储元素的数组以及队列的最大容量等成员变量。
2、实现入队（Enqueue）操作，当队列未满时，将元素添加到队尾，并更新队尾指针。
3、实现出队（Dequeue）操作，当队列不为空时，取出队头元素，并更新队头指针。
4、实现获取队头元素（Front）操作，返回队头元素但不进行出队操作。
5、实现判断队列是否为空（IsEmpty）和判断队列是否已满（IsFull）的操作。
数据结构栈和队列实验报告
错,及时改正. ④ 进行编译与连接。如果在编译与连接过程中发现错误，频幕上会出现“报错信息”，
根据提示找到出错位置与原因,加以改正。再进行编译，如此反复直到不出错为止。 ⑤ 运行程序并分析运行结果就是否合理.在运行就是要注意当输入不同得数据时所得
//插入*p 节点作为开始节点
s->next=p;
}
bool Pop(LiStack *&s,ElemType &e) //出栈
{ LiStack *p;
if (s->next==NULL)
//栈空得情况
return false;
p=s->next;
//p 指向开始节点
e=p->data;
s->next=p->next;
(5）输出链栈长度;
（6）输出从栈底到栈顶元素; （7）输出出队序列； （8）判断链栈 s 就是否非空;
图 3、3 Ｐ
roj３_2 工程组成
(９)释放队列。
本工程 Pｒｏｊ3_2 得组成结构如图３、３所示。本工程得模块结构如图３、4 所示。
图中方框表示函数，方框中指出函数名，箭头方向表示函数间得调用关系。
//指针域
} LiStack;
extern void InitStack(LiStack *&s);
extern void DestroyStack(LiStack *&s);
extern bool StackEmpty(LiStack *s);
C语言数据结构_第04讲 栈
while(n); printf("转换后的二进制数值为："); while(s.top) // 余数出栈处理 { printf("%d",s.top->data); // 输出栈顶的余数 stacknode* p=s.top; // 修改栈顶指针 s.top=s.top->next; delete p; // 回收一个结点，C语言中用free p } }
3-3-2 表达式求值
表达式是由运算对象、运算符、括号等组成的有意义的式子。 1．中缀表达式（Infix Notation） 一般我们所用表达式是将运算符号放在两运算对象的中 间，比如：a+b，c/d等等，我们把这样的式子称为中缀表达 式。 2．后缀表达式（Postfix Notation） 后缀表达式规定把运算符放在两个运算对象（操作数） 的后面。在后缀表达式中，不存在运算符的优先级问题，也 不存在任何括号，计算的顺序完全按照运算符出现的先后次 次序进行。 3．中缀表达式转换为后缀表达式 其转换方法采用运算符优先算法。转换过程需要两个栈： 一个运算符号栈和一个后缀表达式输出符号栈。
（4）读栈顶元素
datatype ReadTop（SeqStack *s） { if (SEmpty ( s ) ) return 0； // 若栈空，则返回0 else return (s->data[s->top] )；
// 否则，读栈顶元素，但指针未移动
}
（5）判栈空
int SEmpty（SeqStack *s） { if （s->top= = –1） return 1； else return 0； }
2．顺序栈运算的基本算法 （1）置空栈 首先建立栈空间，然后初始化栈顶指针。 SeqStack *Snull（） { SeqStack *s； s=new (SeqStack)；
数据结构课程设计题目汇总及要求
数据结构课程设计题目课程设计题一：线性表子系统一．设计目的：1.掌握线性表的特点2.掌握线性表的顺序存储结构和链式存储结构的基本运算3.掌握线性表的基本操作二．设计内容和要求：1.设计一个选择式菜单。
线性表子系统******************************************************* 1 ……建表** 2 ……插入** 3 ……删除** 4 ……显示** 5 ……查找** 6 ……求表长** 0 ……返回*******************************************************请选择菜单号（0…6）：2.采用单链表创建线性表。
3.在线性表中实现插入、删除元素，显示线性表中所有元素，查找元素和求线性表长的基本操作。
课程设计题二：栈子系统一．设计目的：1.掌握栈的特点及其描述方法2.掌握链式存储结构实现一个栈3.掌握链栈的各种基本操作4.掌握栈的典型应用的算法二．设计内容和要求：1.设计一个选择式菜单。
栈子系统****************************************************** * 1 ……入栈* * 2 ……出栈* * 3 ……显示* * 4 ……数制转换* * 0 ……返回* ****************************************************** 请选择菜单号（0…4）：2.设计一个整型数据元素的链栈。
3.编写入栈、出栈和显示栈中全部元素的程序。
4.编写一个把十进制数转换成八进制数的应用程序。
课程设计题三：队列子系统一．设计目的：1.掌握队列的特点及其描述方法2.掌握链式存储结构实现一个队列3.掌握队列的各种基本操作4.掌握队列简单应用的算法二．设计内容和要求：1.设计一个选择式菜单。
队列子系统******************************************************* 1 ……入队** 2 ……出队** 3 ……读队首元素** 4 ……显示** 5 ……报数问题** 0 ……退出*******************************************************请选择菜单号（0…5）：2.设计一个整型数据元素的链队列。
栈的实验报告心得(3篇)
第1篇一、实验背景栈（Stack）是一种先进后出（First In Last Out，FILO）的数据结构，它是计算机科学中常用的数据存储方式之一。
在栈中，元素的插入和删除操作只能在栈顶进行。
本实验旨在通过编程实现栈的基本操作，加深对栈的理解和应用。
二、实验目的1. 理解栈的基本概念和特点。
2. 掌握栈的基本操作，如入栈、出栈、判断栈空、判断栈满等。
3. 熟悉栈在实际问题中的应用，提高编程能力。
三、实验内容1. 栈的定义与实现2. 栈的基本操作a. 入栈（Push）b. 出栈（Pop）c. 判断栈空（IsEmpty）d. 判断栈满（IsFull）e. 获取栈顶元素（Peek）3. 栈的应用实例四、实验过程1. 栈的定义与实现首先，我们需要定义一个栈的数据结构。
在C语言中，可以使用结构体（struct）来实现栈：```cdefine MAX_SIZE 100 // 定义栈的最大容量typedef struct {int data[MAX_SIZE]; // 存储栈元素的数组int top; // 栈顶指针} Stack;```2. 栈的基本操作（1）入栈（Push）入栈操作将一个元素添加到栈顶。
在执行入栈操作之前，需要判断栈是否已满。
如果栈未满，则将元素添加到栈顶；如果栈已满，则返回错误信息。
```cint Push(Stack s, int value) {if (s->top == MAX_SIZE - 1) {return -1; // 栈满}s->data[++s->top] = value; // 将元素添加到栈顶return 0; // 成功入栈}```（2）出栈（Pop）出栈操作将栈顶元素移除。
在执行出栈操作之前，需要判断栈是否为空。
如果栈不为空，则将栈顶元素移除；如果栈为空，则返回错误信息。
```cint Pop(Stack s, int value) {if (s->top == -1) {return -1; // 栈空}value = s->data[s->top--]; // 移除栈顶元素return 0; // 成功出栈}```（3）判断栈空（IsEmpty）判断栈空操作用于判断栈是否为空。
西南科技大学数据结构实验报告栈的基本操作
西南科技大学数据结构实验报告实验名称：栈的基本操作实验环境：windows 7 VS2010实验类别：指导教师：专业班级：姓名：学号：1、掌握栈的链式存储结构2、学会栈基本运算的实现二、实验内容我所做的实验是实验题3.2，编写程序3-2.cpp，实现链栈的各种基本运算，并在此基础上设计一个主程序完成如下功能（1）、初始化链栈s；（2）、判断链栈s是否非空；（3）、依次进栈元素a,b,c,d,e;（4）、判断链栈s是否非空；（5）、输出链栈长度；（6）、输出从栈顶到栈底元素；（7）、输出出链栈序列；（8）、判断链栈s是否非空；（9）、释放链栈。
本次实验我是用C++来完成的，链栈也就是采用单链表实现，链栈的优点是不存在栈满上溢的情况，规定栈的所有操作都是在单链表的表头进行的，所以实现链栈也就是对单链表的简化。
下面具体介绍一下本次实验的实验过程：1、初始化链栈要建立链栈的头结点，并将其next域置为NULL。
2、链栈为空的条件是栈的指针的下一个指向空（s->next==NULL）,也就是单链表中没有数据结点。
3、进栈也就是将新数据结点插入到头结点之后。
4、链栈的长度也就是从第一个数据结点开始扫描单链表，从而保存访问的数据结点的个数，然后将其值返回。
5、从栈顶到栈底元素的输出也就是从第一个数据结点开始扫描单链表吗，并输出当前访问结点的数据域值6、输出出栈序列是在栈不为空的条件下，将头结点的指针域所指数据结点的数据域输出，然后将其空间释放，也就是删除。
7、释放链栈也就是对栈的销毁，释放栈占用的全部存储空间四、实验结果本次实验实现了栈的各种基本运算，并对其进行检验，均没有发生错误，符合实验要求。
五、实验心得通过本次实验，可以说我对单链表的操作再一次熟悉了一遍，并且了解到栈在实际应用当中也很广泛，例如在计算器当中的表达式的求值可以用栈来实现，DFS深度优先搜索也可以用栈来实现，从而解决了求解迷宫问题等等。
《数据结构》实验指导及实验报告栈和队列
《数据结构》实验指导及实验报告栈和队列实验四栈和队列⼀、实验⽬的1、掌握栈的结构特性及其⼊栈，出栈操作；2、掌握队列的结构特性及其⼊队、出队的操作，掌握循环队列的特点及其操作。
⼆、实验预习说明以下概念1、顺序栈：2、链栈：3、循环队列：4、链队三、实验内容和要求1、阅读下⾯程序，将函数Push和函数Pop补充完整。
要求输⼊元素序列1 2 3 4 5 e，运⾏结果如下所⽰。
#include#include#define ERROR 0#define OK 1#define STACK_INT_SIZE 10 /*存储空间初始分配量*/#define STACKINCREMENT 5 /*存储空间分配增量*/typedef int ElemType; /*定义元素的类型*/typedef struct{ElemType *base; /*定义栈底部指针*/ElemType *top; /*定义栈顶部指针*/int stacksize; /*当前已分配的存储空间*/}SqStack;int InitStack(SqStack *S); /*构造空栈*/int push(SqStack *S,ElemType e); /*⼊栈操作*/int Pop(SqStack *S,ElemType *e); /*出栈操作*/int CreateStack(SqStack *S); /*创建栈*/void PrintStack(SqStack *S); /*出栈并输出栈中元素*/int InitStack(SqStack *S){S->base=(ElemType *)malloc(STACK_INT_SIZE *sizeof(ElemType)); if(!S->base) return ERROR;S->top=S->base;int Push(SqStack *S,ElemType e){if(S->top-S->base>=S->stacksize){S->base=(ElemType*)realloc(S->base,(S->stacksize+STACKINCREMENT)*sizeof(ElemType)); S->top=S->base+S->stacksize;S->stacksize+=STACKINCREMENT;}*S->top++=e;return 1}/*Push*/int Pop(SqStack *S,ElemType *e){if(S->top!=S->base){*e=*--S->top;return 1;}elsereturn 0;}/*Pop*/int CreateStack(SqStack *S){int e;if(InitStack(S))printf("Init Success!\n");else{printf("Init Fail!\n");return ERROR;}printf("input data:(Terminated by inputing a character)\n"); while(scanf("%d",&e))Push(S,e);return OK;}/*CreateStack*/while(Pop(S,&e))printf("%3d",e);}/*Pop_and_Print*/int main(){SqStack ss;printf("\n1-createStack\n");CreateStack(&ss);printf("\n2-Pop&Print\n");PrintStack(&ss);return 0;}●算法分析：输⼊元素序列1 2 3 4 5，为什么输出序列为5 4 3 2 1？体现了栈的什么特性？2、在第1题的程序中，编写⼀个⼗进制转换为⼆进制的数制转换算法函数（要求利⽤栈来实现），并验证其正确性。
实验2 栈子系统
实验二栈子系统1、实验目的（1）掌握栈的特点及其描述方法。
（2）用链式存储结构实现一个栈。
（3）掌握建栈的各种基本操作。
（4）掌握栈的几个典型应用的算法。
2、实验内容（1）设计一个字符型的链栈。
（2）编写进栈，出栈，显示栈中全部元素的程序。
（3）编写一个把十进制整数转换成二进制数的应用程序。
（4）用switch语句设计一个选择式菜单，以菜单方式选择上述操作。
栈子系统*********************************************** 1------------进栈** 2------------出栈** 3------------显示** 4------------进制转换** 0------------返回***********************************************请选择菜单号（0—5）：3．参考程序#include<stdio.h>#include<malloc.h>#define MAXLEN 100typedef int DataType;typedef struct Lsnode // 定义栈的存储结构{ DataType data;struct Lsnode *next;} Lsnode ;typedef struct{ Lsnode *top; // 定义栈顶的指针}linkstack;void ShowStack(linkstack *s) // 显示栈内元素{Lsnode *p=s->top;if(p==NULL)printf("\t\t栈内为空。
\n");else{ printf("\t\t栈元素为：");while (p!=NULL){ printf("%6d",p->data);p=p->next;}}}void main(){ linkstack *s=new linkstack;int i=1,j=1,choice,val,n;char a;s->top=NULL;while(i){printf("\n\n\n\n");printf("\n\t\t 栈子系统\n");printf("\n\t\t**********************************************");printf("\n\t\t* 1------------进栈*");printf("\n\t\t* 2------------出栈*");printf("\n\t\t* 3------------显示*");printf("\n\t\t* 4------------进制转换*");printf("\n\t\t* 0------------返回*");printf("\n\t\t**********************************************");printf("\n\t\t请选择菜单号（0-5）：");choice=getchar();getchar();switch (choice){case '1':while(j){ printf("\t\t 请键入一个整数（按回车输入下一个，输入'0'结束）：");scanf("%d",&val);getchar();if(val!=0)Push (s,val);else j=0;}break;case '2':if(s->top!=NULL)printf("\t\t 出栈元素为：%6d\n",Pop(s));break;case '3':ShowStack (s);break;case '4':printf("\n\t\t请输入一个十进制正整数：");scanf("%d",&n);Conversion(n);break;case '0':i=0;break;default:;}if (choice=='1'||choice=='2'||choice=='3'||choice=='4'){ printf("\n\t\t 按回车键继续，按任意键返回！");a=getchar ();if (a!='\xA')i=0;}}}。
数据结构栈的实验报告
数据结构栈的实验报告篇一：数据结构栈和队列实验报告一、实验目的和要求(1)理解栈和队列的特征以及它们之间的差异，知道在何时使用那种数据结构。
(2)重点掌握在顺序栈上和链栈上实现栈的基本运算算法，注意栈满和栈空的条件。
(3)重点掌握在顺序队上和链队上实现队列的基本运算算法，注意循环队队列满和队空的条件。
(4)灵活运用栈和队列这两种数据结构解决一些综合应用问题。
二、实验环境和方法实验方法：（一）综合运用课本所学的知识，用不同的算法实现在不同的程序功能。
（二）结合指导老师的指导，解决程序中的问题，正确解决实际中存在的异常情况，逐步改善功能。
（三）根据实验内容，编译程序。
实验环境：Windows xpVisual C++6.0三、实验内容及过程描述实验步骤：①进入Visual C++ 6.0集成环境。
②输入自己编好的程序。
③检查一遍已输入的程序是否有错（包括输入时输错的和编程中的错误），如发现有错，及时改正。
④进行编译和连接。
如果在编译和连接过程中发现错误，频幕上会出现“报错信息”，根据提示找到出错位置和原因，加以改正。
再进行编译，如此反复直到不出错为止。
⑤运行程序并分析运行结果是否合理。
在运行是要注意当输入不同的数据时所得结果是否正确，应运行多次，分别检查在不同情况下结果是否正确。
实验内容：编译以下题目的程序并调试运行。
1）、编写一个程序algo3-1.cpp，实现顺的各种基本运算，并在此基础上设计一程序并完成如下功能：（1）初始化栈s；（2）判断栈s是否非空；序栈个主（3）依次进栈元素a,b,c,d,e；（4）判断栈s是否非空；（5）输出出栈序列；（6）判断栈s是否非空；（7）释放栈。
图3.1 Proj3_1 工程组成本工程Proj3_1的组成结构如图3.1所示。
本工程的模块结构如图3.2所示。
图中方框表示函数，方框中指出函数名，箭头方向表示函数间的调用关系。
图3.2 Proj3_1工程的程序结构图其中包含如下函数：InitStack(SqStack * s) //初始化栈SDestroyStack(SqStack * s) //销毁栈sStackEmpty(SqStack *s) //判断栈空Push(SqStack * s,ElemType e) //进栈Pop(SqStack * s,ElemType e) //出栈GetTop(SqStack *s,ElemType e) //取栈顶元素对应的程序如下：//文件名:algo3-1.cpp#include stdio.h#include malloc.h#define MaxSize 100typedef char ElemType;typedef struct{ElemType data[MaxSize];int top; //栈顶指针} SqStack;void InitStack(SqStack * s) //初始化栈S { s=(SqStack *)malloc(sizeof(SqStack));s- top=-1; //栈顶指针置为-1}void DestroyStack(SqStack * s) //销毁栈s{free(s);}bool StackEmpty(SqStack *s) //判断栈空{return(s- top==-1);}bool Push(SqStack * s,ElemType e) //进栈{ if (s- top==MaxSize-1) //栈满的情况，即栈上溢出 return false;s- top++; //栈顶指针增1s- data[s- top]=e; //元素e放在栈顶指针处return true;}bool Pop(SqStack * s,ElemType e) //出栈{ if (s- top==-1) //栈为空的情况，即栈下溢出return false;e=s- data[s- top]; //取栈顶指针元素的元素s- top--;//栈顶指针减1return true;}bool GetTop(SqStack *s,ElemType e) //取栈顶元素 { if (s- top==-1) //栈为空的情况，即栈下溢出return false;e=s- data[s- top]; //取栈顶指针元素的元素return true;}设计exp3-1.cpp程序如下 //文件名:exp3-1.cpp#include stdio.h#include malloc.h#define MaxSize 100typedef char ElemType;typedef struct{ElemType data[MaxSize];int top; //栈顶指针} SqStack;extern void InitStack(SqStack *extern void DestroyStack(SqStack *extern bool StackEmpty(SqStack *s);extern bool Push(SqStack * s,ElemType e);extern bool Pop(SqStack * s,ElemTypeextern bool GetTop(SqStack *s,ElemTypevoid main(){ElemType e;SqStack *s;printf( 栈s的基本运算如下:\nprintf( (1)初始化栈s\nInitStack(s);printf( (2)栈为%s\n ,(StackEmpty(s)? 空 : 非空 )); printf( (3)依次进栈元素a,b,c,d,e\nPush(s, aPush(s, bPush(s, cPush(s, dPush(s, eprintf( (4)栈为%s\n ,(StackEmpty(s)? 空 : 非空 )); printf( (5)出栈序列:while (!StackEmpty(s)){Pop(s,e);printf( %c ,e);}printf( \nprintf( (6)栈为%s\n ,(StackEmpty(s)? 空 : 非空 ));printf( (7)释放栈\nDestroyStack(s);}运行结果如下：2）、编写一个程序algo3-2.cpp，实现链栈的各种基本运算，并在此基础上设计一个主程序并完成如下功能：（1）初始化链栈s；（2）判断链栈s是否非空；（3）依次进栈a，b，c，d，e；（4）判断链栈s是否非空；（5）输出链栈长度；（6）输出从栈底到栈顶元素；（7）输出出队序列；（8）判断链栈s是否非空；图3.3 Proj3_2工程组成（9）释放队列。
数据结构实验报告 栈和队列
2007级数据结构实验报告实验名称：实验二栈和队列日期：2008年11月15日1．实验要求实验目的通过选择下面五个题目之一进行实现，掌握如下内容：进一步掌握指针、模板类、异常处理的使用掌握栈的操作的实现方法掌握队列的操作的实现方法学习使用栈解决实际问题的能力学习使用队列解决实际问题的能力实验内容2.1题目1根据栈和队列的抽象数据类型的定义，按要求实现一个栈或一个队列。
要求：1、实现一个共享栈2、实现一个链栈3、实现一个循环队列4、实现一个链队列编写测试main()函数测试线性表的正确性。
2. 程序分析2.1 存储结构存储结构：特殊线性表：栈，队列栈顶 栈底 链栈2.2 关键算法分析共享栈的入栈算法伪码（Push ）： 1．如果栈满，抛出上溢异常。
2．判断是插在栈1还是栈2：2.1如果在栈1插入，则栈顶指针top1加1，在top1处填入元素x ； 2.2如果在栈2插入，则栈顶指针top2加1，在top2处填入元素x 。
共享栈的出栈算法伪码（Pop ）：1. 判断是在栈1删除还是在栈2删除。
2. 若是在栈1删除，则2.1 若栈1为空栈，抛出下溢异常； 2.2 删除并返回栈1的栈顶元素；3. 若是在栈2删除，则3.1 若栈2为空栈，抛出下溢异常； 3.2 删除并返回栈2的栈顶元素。
非空链队列 空链队列共享栈的取栈顶元素算法伪码（GetTop）：1．判断是在栈1取还是栈2取；2．如果在栈1取，则2.1 若栈1不空，返回栈顶元素的值，不删除；2.2 若栈1空，返回0；3．如果在栈2取，则3.1 若栈2不空，返回栈顶元素的值，不删除；3.2 若栈2空，返回0。
链栈的入栈算法伪码（Push）：1．申请一个新的结点，数据域为x；2．将新结点插在栈顶；3．栈顶指针重新指向栈顶元素。
链栈的出栈算法伪码（Pop）：1．如果栈空，抛出下溢异常；2．暂存栈顶元素；3．将栈顶结点摘链；4．删除该结点，返回该元素的值。
链栈的取栈顶元素算法的伪码（GetTop）：1．如果栈非空，返回栈顶元素的值，不删除。
栈和队列实验报告
数据结构实验报告顺序栈的实现和基本操作一、需求分析（1）顺序栈◆栈的典型操作是入栈和出栈，前者将新元素压入栈中，后者弹出栈顶元素。
栈只提供对栈顶元素的访问操作，由top ( )完成。
Push ( )和Pop ( )还有Top ( )共同构成了栈的最小功能接口。
此外，为了方便使用，栈还有判空，判满和输出栈等功能。
◆输入形式及范围：输入形式为整型，范围为0~65535。
◆输出形式：在顺序栈的初始化后显示初始化成功，在判断栈是否为空时显示当前栈为空，入栈后显示入栈成功或者栈已满。
出栈时显示出栈元素或者栈为空。
输出栈时依次显示栈中元素。
◆程序功能：初始化栈，判断栈是否为空，判断栈是否为满，入栈，出栈，取栈顶元素，出栈同时返回栈顶元素和输出栈等功能。
◆测试数据：初始化后输入栈的长度为4。
判断栈是否为空。
进行5次入栈操作。
分别输入1 2 3 4 5输出栈。
执行2次出栈操作。
输出栈。
查看栈顶元素。
输出栈。
（2）队列◆队列的典型操作是入队和出队，前者将新元素压入队列中，后者弹出队首头元素。
队列只提供对队头元素和队尾元素的操作，由DeQueue ( ) 和EnQueue( )完成。
DeQueue还有EnQueue ( )共同构成了队列的最小功能接口。
此外，为了方便使用，队列还有判空，判满和输出队列等功能。
◆输入形式及范围：输入形式为整型，范围为0~65535。
◆输出形式：在顺序队列的初始化后显示初始化成功，在判断队列是否为空时显示当前队列为空，入队列后显示入队成功或者队列已满。
出队列时显示出队首元素或者队列为空。
输出队列时依次显示队列中元素。
◆程序功能：初始化队列，判断队列是否为空，判断队列是否为满，入队，出队，取队首元素，输出队列等功能。
◆测试数据：初始化后输入队列的长度为54。
判断队列是否为空。
进行5次入队操作。
分别输入1 2 3 4 5输出队列。
执行2次出队操作。
输出队列。
查看队首元素。
输出队列。
二、概要设计（1）顺序栈◆为了实现程序的功能，在.H文件中定义了栈的模板类. template <class T>class Stack{私有数据成员：private:栈的最大长度int MaxSize;栈顶位置int top;顺序栈首地址T *theArray;公有成员：public:栈的初始化void InitStack(int capacity=10);操作结果：初始化一个默认长度为10的空栈判断栈是否为空bool IsEmpty() const;初始条件：栈已存在。
数据结构：栈子系统
/**题目：设计一个字符型的链栈。
* 编写进栈、出栈、显示栈中全部元素的程序。
*题目：编写一个把十进制整数转换为二进制数的应用程序*题目：编写一个把中缀表达式转换为后缀表达式〔逆波兰式〕的应用程序*题目：设计一个选择式菜单，以菜单方式选择上述操作。
* 栈子系统* ******************************** * 1------进栈** * 2------出栈** * 3------显示** * 4------数值转换** * 5------逆波兰式** * 0------返回** ******************************** 请选择菜单号〔0--5〕：*/*include <stdio.h>*include <stdlib.h>*define STACKMAX 50typedef struct sta //栈的存储构造{int data;struct sta *next;}stackNode;typedef struct //指向栈顶的指针{stackNode *top;}linkStack;void conversion(int n);void push(linkStack *p, int x);int pop(linkStack *p);void showStack(linkStack *p);void sufflx();/*************************************************Function: main()Description: 主调函数Calls: push()pop()showStack()conversion()Input: NULLReturn: voidOthers: NULL*************************************************/void main(){int x, choice, i = 1;linkStack p;p.top = NULL; //置空栈while (i){printf("\n 栈子系统\n");printf("*******************************\n");printf("* 1------进栈*\n");printf("* 2------出栈*\n");printf("* 3------显示*\n");printf("* 4------数值转换*\n");printf("* 5------逆波兰式*\n");printf("* 0------返回*\n");printf("*******************************\n");printf("请选择菜单号〔0--5〕：");fflush(stdin); //清空输入的缓存区choice = getchar();switch(choice){case '1':while (1){printf("请输入一个整数〔‘0’表示完毕〕并按回车：");scanf("%d", &x);if (x != 0){push(&p, x); //入栈}else{break;}}break;case '2':x = pop(&p); //出栈if (x > 0){printf("出栈元素为：%d\n", x);}else{printf("栈为空，没有元素可以出栈！\n");}break;case '3':showStack(&p); //显示栈元素break;case '4':printf("请输入十进制数：");scanf("%d", &x);conversion(x); //数值转换break;case '5':sufflx();break;case '0':i = 0;break;default:i = 1;break;}}}/************************************************* Function: conversion()Description: 十进制数转换二进制数Calls: push()pop()Input: n :输入的要转换的数Return: voidOthers: NULL*************************************************/void conversion(int n){linkStack s;int x, i = 1;s.top = NULL; //置空栈do{x = n%2; //求余数n = n/2; //求新商push(&s, x); //入栈}while (n);printf("转化的二进制为：");while (i){x = pop(&s); //出栈if (x != -1) //判断是否全部出栈{printf("%d", x);}else{i = 0;}}printf("\n");}void sufflx(){char str[STACKMAX]; //存储中缀表达式char exp[STACKMAX]; //存储后缀表达式char stark[STACKMAX]; //顺序栈来存放运算符int top = 0; //顺序栈置空int sum, t, i = 0;char ch;printf("请输入一个算术表达式〔运算符只能包含+，-，*，/〕，以*完毕：\n");fflush(stdin);do{i++;scanf("%c", &str[i]);} while (str[i] != '*' && i != STACKMAX); //存储用户输入的中缀表达式sum = i; //保存表达式的长度i = t = 1;ch = str[i];i++;while (ch != '*'){switch (ch){case '(': //读取到‘〔’时，入栈top++;stark[top] = ch;break;case ')': //读取到‘〕’时while (stark[top] != '('){exp[t++] = stark[top--]; //出栈并赋值给输出数组exp[t++] = ','; //添加分割符号}top--; //栈顶元素为‘〔’时，出栈break;case '+': //读取到‘+’时while (top != 0 && stark[top] != '(') //判断符号优先级{exp[t++] = stark[top--];exp[t++] = ',';}stark[++top] = ch; //栈为空时入栈break;case '-': //读取到‘-’时while (top != 0 && stark[top] != '('){exp[t++] = stark[top--];exp[t++] = ',';}stark[++top] = ch; //栈为空时入栈break;case '*': //读取到‘*’时while (stark[top] == '*' || stark[top] == '/') //*、/运算级最高{exp[t++] = stark[top--];exp[t++] = ',';}stark[++top] = ch; //运算符优先级高的入栈break;case '/': //读取到‘/’时while (stark[top] == '*' || stark[top] == '/'){exp[t++] = stark[top--];exp[t++] = ',';}stark[++top] = ch; //运算符优先级高的入栈break;case ' ': //读取到空格时忽略break;default: //不是运算符号时while (ch >= '0' && ch <= 'z') //限制输入的变量{exp[t++] = ch;ch = str[i++];}i--; //上面多加的要去掉exp[t++] = ',';break;}ch = str[i++];}while (top != 0) //顺序栈中仍有数值时{exp[t++] = stark[top--];if (top != 0){exp[t++] = ',';}}printf("中缀表达式为："); //输出for (i = 1; i < sum; i++){printf("%c", str[i]);}printf("\n后缀表达式为：");for (i = 1; i < t; i++){printf("%c", exp[i]);}}/************************************************* Function: push()Description: 入栈Calls: NULLInput: *p：栈的栈顶指针x ：要入栈的数Return: voidOthers: NULL*************************************************/ void push(linkStack *p, int x) //入栈{stackNode *q;q = (stackNode *)malloc(sizeof(stackNode));q->data = x;q->next = p->top;p->top = q;}/************************************************* Function: pop()Description: 出栈Calls: NULLInput: *p：栈的栈顶指针Return: intOthers: NULL*************************************************/ int pop(linkStack *p) //出栈{stackNode *q;int x;if (p->top != NULL){q = p->top;x = q->data;p->top = q->next;free(q);return x; //返回栈顶元素}else{return -1;}}/************************************************* Function: showStack()Description: 显示栈中元素Calls: NULLInput: *p：栈的栈顶指针Return: voidOthers: NULL*************************************************/ void showStack(linkStack *p){stackNode *q;q = p->top;if (q != NULL){printf("栈元素为：");while (q != NULL){printf("%4d", q->data);q = q->next;}printf("\n");}else{printf("栈为空。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
验证性实验3：栈子系统班级学号 20 姓名施程程1．实验目的（1）掌握栈的特点及其描述方法。
（2）用链式存储结构实现一个栈。
（3）掌握建栈的各种基本操作。
（4）掌握栈的几个典型应用的算法。
2．实验内容（1）设计一个字符型的链栈。
（2）编写进栈、出栈、显示栈中全部元素的程序。
（3）编写一个把十进制整数转换成二进制数的应用程序。
（4）编写一个把中缀表达式转换成后缀表达式（逆波兰式）的应用程序。
（5）设计一个选择式菜单，以菜单方式选择上述操作。
栈子系统*********************************************** 1---------进栈 ** 2---------出栈 ** 3---------显示 ** 4---------数制转换 ** 5---------逆波兰式 ** 0---------返回 ***********************************************请选择菜单号（0--5）：3．实验程序（附zhan.cpp）#include <stdio.h>#include <stdlib.h>#define STACKMAX 100typedef struct stacknode{int data;struct stacknode *next;}StackNode;typedef struct{StackNode *top;}LinkStack;void Push (LinkStack &s,int x){StackNode *p=new StackNode;p->data=x;p->next=s.top;s.top=p;}int Pop(LinkStack &s,int &x){StackNode *p;if(s.top!=NULL){p=s.top;x=p->data;s.top=p->next;delete p;return 1;}elsereturn 0;}void ShowStack (LinkStack s){StackNode *p=s.top;if (p==NULL)printf("\n\t\t栈为空。
");else{printf("\n\t\t栈元素为： ");while (p!=NULL){printf("%6d",p->data);p=p->next;}printf("\n");}}void Conversion(int n){LinkStack s;int x;s.top=NULL;do{x=n%2;n=n/2;Push(s,x);}while(n);printf("\n\t\t转换后的二进制数值： ");while (Pop(s,x))printf("%d",x);printf("\n");}void Suffix(){char str[STACKMAX];char stack[STACKMAX];char exp[STACKMAX];char ch;int sum,i,j,t,top=0;printf("\n\t\t输入算术表达式(算术符只能包含+,-,*,/),以#结束:\n\t\t");fflush(stdin);i=0;do{i++;scanf("%c",&str[i]);}while(str[i]!='#'&& i!=STACKMAX);sum=i;t=1;i=1;ch=str[i];i++;while (ch!='#'){switch (ch){case '(':top++;stack[top]=ch;break;case ')':while (stack[top]!='('){exp[t++]=stack[top--];exp[t++]=',';}top--;break;case '+':case '-':while (top!=0 && stack[top]!='('){exp[t++]=stack[top--];exp[t++]=',';}stack[++top]=ch;break;case '*':case '/':while(stack[top]=='*' || stack[top]=='/'){exp[t++]=stack[top--];exp[t++]=',';}stack[++top]=ch;break;case ' ':break;default:while (ch>='0'&&ch<='z'){exp[t++]=ch;ch=str[i++];}i--;exp[t++]=',';}ch=str[i++];}while (top!=0){exp[t++]=stack[top--];if(top!=0)exp[t++]=',';}printf("\n\t\t输入的中缀表达式是: ");for(j=1;j<sum;j++)printf("%c",str[j]);printf("\n\n\t\t后缀表达式是: ");for(j=1;j<t;j++)printf("%c",exp[j]);printf("\n");}void main(){LinkStack s;int i=1,j=1,val,n;char choice;s.top=NULL;while(1){printf("\n");printf("\n\t\t 栈子系统 ");printf("\n\t\t**********************");printf("\n\t\t* 1--进栈 *");printf("\n\t\t* 2--出栈 *");printf("\n\t\t* 3--显示 *");printf("\n\t\t* 4--数制转换 *");printf("\n\t\t* 5--逆波兰式 *");printf("\n\t\t* 0--退出程序 *");printf("\n\t\t**********************");printf("\n\t\t 请选择菜单号(0--5): ");fflush(stdin);choice=getchar();switch (choice){case '1':while (1){printf("\n\t\t输入一个整数('0'表示结束)并按回车: ");scanf("%d",&val);if (val!=0)Push (s,val);elsebreak;}break;case '2':if (Pop(s,val))printf("\n\t\t出栈元素为: %6d",val);elseprintf("\n\t\t栈为空，没有元素可以出栈! \n");break;case '3':ShowStack(s);break;case '4':printf("\n\t\t请输入一个十进制正整数: ");scanf("%d",&n);Conversion(n);break;case '5':Suffix();break;case '0':exit(0);default:printf("\n\t\t输入的菜单错误，请重新输入! \n");}}}4. 运行结果5．实验小结本章主要要求我们掌握栈的特点及其描述方法，就是进栈、出栈、数字转换、逆波兰式等的程序是怎样的。
这个实验要求设计的是一个字符型链栈，其中要求有进栈、出栈、显示栈中全部元素、把十进制转换成二进制以及中缀表达式转换成后缀表达式的程序。
根据书上所给的参考程序，我自己先看了一遍，基本上能看懂，哪段程序是进栈的程序，哪段程序是表示出栈，显示栈中元素也能找到，数字转换和把中缀表达式转换成后缀表达式也知道是哪一段。
在编译的时候这一次没有错误，我很高兴。
在执行的时候，操作很简单，没有什么问题，看着结果的出现，怀着的是一种激动的心情。
本次实验是成功的，在实验中我更好的理解了栈的运用，牢记了栈是后进先出的特点。