数据结构实验-栈的基本运算
栈的实验报告结论(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）测试程序：验证了栈在程序设计中的应用。
顺序栈的基本运算
顺序栈的基本运算顺序栈是一种经典的数据结构，它是基于数组实现的一种数据结构，具有先进后出（LIFO）的特点。
顺序栈在计算机科学和软件开发中有广泛的应用，是我们学习数据结构和算法的重要基础。
顺序栈的基本运算主要包括入栈、出栈、判空和获取栈顶元素。
下面我们将逐一介绍这些运算。
1. 入栈：入栈即向顺序栈中添加一个元素。
入栈操作需要把元素放入数组中的下一个空闲位置，并更新栈顶指针。
当数组已满时，无法进行入栈操作，这种情况称为栈溢出。
2. 出栈：出栈即从顺序栈中移除栈顶元素。
出栈操作实际上是将栈顶指针减一，并返回栈顶元素的值。
当栈为空时，无法进行出栈操作，这种情况称为栈下溢。
3. 判空：判空操作是判断顺序栈中是否没有任何元素。
可以通过检查栈顶指针是否为-1来判断栈是否为空。
4. 获取栈顶元素：获取栈顶元素是通过返回栈顶指针指向的元素来实现的。
获取栈顶元素不会改变栈的状态。
以上就是顺序栈的基本运算，通过这些运算，我们可以方便地进行栈的操作。
顺序栈的使用可以帮助我们解决许多实际问题。
顺序栈在实际中有许多应用。
例如，我们可以使用顺序栈来实现浏览器的前进和后退功能。
每次访问一个新的网页时，我们可以将当前网页的信息入栈；当点击后退按钮时，我们可以出栈以获取上一个访问过的网页信息。
另一个例子是编辑器中的撤销操作，我们可以使用顺序栈来存储每次操作的历史记录，当需要进行撤销操作时，可以通过出栈操作来获取前一个状态。
在编程中使用顺序栈时，我们要注意栈溢出和栈下溢的情况。
为了避免栈溢出，我们应该在进行入栈操作之前判断栈是否已满；为了避免栈下溢，我们应该在进行出栈操作之前判断栈是否为空。
总结而言，顺序栈是一种简单而有效的数据结构，可以帮助我们解决许多实际问题。
通过掌握顺序栈的基本运算，我们可以更好地理解数据结构和算法的原理，为软件开发和问题解决提供有力支持。
数据结构栈和队列实验报告
数据结构栈和队列实验报告实验报告：数据结构栈和队列一、实验目的1.了解栈和队列的基本概念和特点；2.掌握栈和队列的基本操作；3.掌握使用栈和队列解决实际问题的方法。
二、实验内容1.栈的基本操作实现；2.队列的基本操作实现；3.使用栈和队列解决实际问题。
三、实验原理1.栈的定义和特点：栈是一种具有后进先出(LIFO)特性的线性数据结构，不同于线性表，栈只能在表尾进行插入和删除操作，称为入栈和出栈操作。
2.队列的定义和特点：队列是一种具有先进先出(FIFO)特性的线性数据结构，不同于线性表，队列在表头删除元素，在表尾插入元素，称为出队和入队操作。
3.栈的基本操作：a.初始化：建立一个空栈；b.入栈：将元素插入栈的表尾；c.出栈：删除栈表尾的元素，并返回该元素；d.取栈顶元素：返回栈表尾的元素，不删除。
4.队列的基本操作：a.初始化：建立一个空队列；b.入队：将元素插入队列的表尾；c.出队：删除队列表头的元素，并返回该元素；d.取队头元素：返回队列表头的元素，不删除。
四、实验步骤1.栈的实现：a.使用数组定义栈，设置栈的大小和栈顶指针；b.实现栈的初始化、入栈、出栈和取栈顶元素等操作。
2.队列的实现：a.使用数组定义队列，设置队列的大小、队头和队尾指针；b.实现队列的初始化、入队、出队和取队头元素等操作。
3.使用栈解决实际问题：a.以括号匹配问题为例，判断一个表达式中的括号是否匹配；b.使用栈来实现括号匹配，遍历表达式中的每个字符，遇到左括号入栈，遇到右括号时将栈顶元素出栈，并判断左右括号是否匹配。
4.使用队列解决实际问题：a.以模拟银行排队问题为例，实现一个简单的银行排队系统；b.使用队列来模拟银行排队过程，顾客到达银行时入队，处理完业务后出队，每个顾客的业务处理时间可以随机确定。
五、实验结果与分析1.栈和队列的基本操作实现：a.栈和队列的初始化、入栈/队、出栈/队以及取栈顶/队头元素等操作均能正常运行；b.栈和队列的时间复杂度均为O(1)，操作效率很高。
数据结构实验报告 栈进制转换
数据结构实验报告栈进制转换数据结构实验报告栈进制转换一、实验目的栈是一种常见的数据结构，本实验的目的在于通过实现栈的基本操作，设计并实现一个进制转换的程序，并通过实验验证程序的正确性和效率。
二、实验原理1.栈的定义和基本操作栈是一种后进先出（Last In First Out，简称LIFO）的数据结构。
它可以通过一个指针来标识当前栈顶元素，栈顶指针top的起始值为-1，空栈时top=-1.2.栈的进制转换将一个十进制数转换为其他进制（如二进制、八进制、十六进制）的过程中，可以通过栈来实现。
具体步骤如下：- 初始化一个空栈；- 将十进制数依次除以目标进制的基数，将余数依次入栈，直到商为0；- 依次出栈，将出栈的余数组合起来，得到转换后的目标进制数。
三、实验内容1.实现栈的基本操作（1）定义栈结构，包括元素数组和栈顶指针；（2）实现入栈操作push()，将元素插入到栈顶；（3）实现出栈操作pop()，从栈顶删除一个元素并返回其值；（4）实现获取栈顶元素的操作getTop()，返回栈顶元素的值；（5）实现判断栈是否为空的操作isEmpty()，返回布尔值；（6）实现判断栈是否已满的操作isFull()，返回布尔值。
2.设计并实现进制转换的程序（1）初始化一个空栈用于存放转换后的数字；（2）输入十进制数num和目标进制target；（3）通过栈的操作将num转换为target进制数；（4）输出转换后的结果。
四、实验步骤1.实现栈的基本操作（1）定义栈的结构和相关操作；（2）编写相应的测试代码，验证栈的基本操作是否正确。
2.设计并实现进制转换的程序（1）根据原理部分的步骤，设计转换程序的具体逻辑；（2）编写相应的测试代码，验证转换程序的正确性和效率。
五、实验结果与分析1.给定一个十进制数num=12345，目标进制为二进制（target=2），经过进制转换后得到的结果为.111.2.给定一个十进制数num=456，目标进制为八进制（target=8），经过进制转换后得到的结果为.710.本实验的结果表明，转换程序能够正确地将十进制数转换为目标进制数，并且具有较高的效率。
实验二--栈的应用---算术表达式的计算
浙江大学城市学院实验报告课程名称数据结构与算法实验项目名称实验二栈的应用---算术表达式的计算实验成绩指导老师（签名）日期一.实验目的和要求1．进一步掌握栈的基本操作的实现。
2．掌握栈在算术表达式的计算方面的应用。
二. 实验内容1. 编写程序利用栈将中缀表达式转换成后缀表达式，即从键盘输入任一个中缀表达式（字符串形式），转换成后缀表达式后，将后缀表达式输出。
假设：中缀表达式包含圆括号( ) 及双目运算符+、-、*、/、^（乘方）。
要求：把栈的基本操作的实现函数存放在头文件stack1.h中（栈元素的类型为char），在主文件test6_2.cpp中包含将中缀表达式S1转换成后缀表达式S2的转换函数void Change( char *S1, char *S2 )及主函数，在主函数中进行输入输出及转换函数的调用。
2. 选做：编写利用栈对后缀表达式进行求值的函数double Compute(char *str)，以计算从前述程序得到的后缀表达式的值。
要求：把栈的基本操作的实现函数存放在头文件stack2.h中（栈元素的类型为double），在主文件test6_2.cpp中添加后缀表达式求值函数，并在主函数中增加调用求值函数及输出结果值的语句。
3. 填写实验报告，实验报告文件取名为report2.doc。
4. 上传实验报告文件report2.doc与源程序文件stack1.h、stack2.h（若有）及test6_2.cpp到Ftp服务器上你自己的文件夹下。
二.函数的功能说明及算法思路（算法思路见源程序的注释部分）//栈的顺序存储结构定义struct Stack{ElemType *stack;int top;int MaxSize;};//初始化栈S为空void InitStack(Stack &S)//元素item进栈，即插入到栈顶void Push(Stack &S,ElemType item)//删除栈顶元素并返回ElemType Pop(Stack &S)//读取栈顶元素的值ElemType Peek(Stack &S)//判断S是否为空，若是则返回true，否则返回false bool EmptyStack(Stack &S)//清除栈S中的所有元素，释放动态存储空间void ClearStack(Stack &S)//将中缀算术表达式转换为后缀算术表达式void Change(char *S1,char *&S2)//返回运算符op所对应的优先级数值int Precedence(char op)//计算由str所指字符串的后缀表达式的值double Compute(char *str)四. 实验结果与分析五. 心得体会【附录----源程序】test6_2.cpp#include<iostream.h>#include<stdlib.h>#include<math.h>#include"stack1.h"#include"stack2.h"void main(){char x[30],y[30];double r;while(1){cout<<"请输入一个中缀算术表达式：";cin.getline(x,sizeof(x));Change(x,y);cout<<"对应的后缀算术表达式为：";cout<<y<<endl;r=Compute(y);cout<<"后缀算术表达式值为："<<r<<endl<<endl;}}stack1.htypedef char ElemType1;struct Stack1{ElemType1 *stack;int top;int MaxSize;};void InitStack(Stack1 &S){S.MaxSize=10;S.stack=new ElemType1[S.MaxSize];if(!S.stack){cerr<<"动态储存分配失败"<<endl;exit(1);}S.top=-1;}void Push(Stack1 &S,ElemType1 item)if(S.top==S.MaxSize-1){int k=sizeof(ElemType1);S.stack=(ElemType1*)realloc(S.stack,2*S.MaxSize*k);S.MaxSize=2*S.MaxSize;}S.top++;S.stack[S.top]=item;}ElemType1 Pop(Stack1 &S){if(S.top==-1){cerr<<"Stack is empty! "<<endl;exit(1);}S.top--;return S.stack[S.top+1];}ElemType1 Peek(Stack1 &S){if(S.top==-1){cerr<<"Stack is empty! "<<endl;exit(1);}return S.stack[S.top];}bool EmptyStack(Stack1 &S){return S.top==-1;}void ClearStack(Stack1 &S){if(S.stack){delete []S.stack;S.stack=0;}S.top=-1;S.MaxSize=0;}//返回运算符op所对应的优先级数值int Precedence(char op){switch(op){case'+':case'-':return 1;case'*':case'/':return 2;case'^':return 3;case'(':case'@':default:return 0;}}//将中缀算术表达式转换为后缀算术表达式void Change(char *S1,char *S2){Stack1 R;InitStack(R);Push(R,'@');int i=0,j=0;char ch=S1[i];while(ch!='\0'){//对于空格字符不做任何处理，顺序读取下一个字符if(ch==' ')ch=S1[++i];//对于左括号，直接进栈else if(ch=='('){Push(R,ch);ch=S1[++i];}//对于右括号，使括号内的仍停留在栈中的运算符依次出栈并写入S2else if(ch==')'){while(Peek(R)!='(')S2[j++]=Pop(R);Pop(R);//删除栈顶的左括号ch=S1[++i];}//对于运算符，使暂存于栈顶且不低于ch优先级的运算符依次出栈并写入S2else if(ch=='+'||ch=='-'||ch=='*'||ch=='/'||ch=='^'){char w=Peek(R);while(Precedence(w)>=Precedence(ch)){S2[j++]=w;Pop(R);w=Peek(R);}Push(R,ch);//把ch运算符写入栈中ch=S1[++i];}else{if((ch<'0'||ch>'9')&&ch!='.'){cout<<"中缀表达式表示错误！"<<endl;exit(1);}while((ch>='0'&&ch<='9')||ch=='.'){S2[j++]=ch;ch=S1[++i];}S2[j++]=' ';}}//把暂存在栈中的运算符依次退栈并写入到S2中ch=Pop(R);while(ch!='@'){if(ch=='('){cerr<<"expression error!"<<endl;exit(1);}else{S2[j++]=ch;ch=Pop(R);}}S2[j++]='\0';}stack2.htypedef double ElemType2;struct Stack2{ElemType2 *stack;int top;int MaxSize;};void InitStack(Stack2 &S){S.MaxSize=10;S.stack=new ElemType2[S.MaxSize];if(!S.stack){cerr<<"动态储存分配失败"<<endl;exit(1);}S.top=-1;}void Push(Stack2 &S,ElemType2 item){if(S.top==S.MaxSize-1){int k=sizeof(ElemType2);S.stack=(ElemType2*)realloc(S.stack,2*S.MaxSize*k);S.MaxSize=2*S.MaxSize;}S.top++;S.stack[S.top]=item;}ElemType2 Pop(Stack2 &S){if(S.top==-1){cerr<<"Stack is empty! "<<endl;exit(1);}S.top--;return S.stack[S.top+1];}ElemType2 Peek(Stack2 &S){if(S.top==-1){cerr<<"Stack is empty! "<<endl;exit(1);}return S.stack[S.top];}bool EmptyStack(Stack2 &S){return S.top==-1;}void ClearStack(Stack2 &S){if(S.stack){delete []S.stack;S.stack=0;}S.top=-1;S.MaxSize=0;}//计算由str所指字符串的后缀表达式的值double Compute(char *str){Stack2 S;InitStack(S);double x,y;int i=0;while(str[i]){if(str[i]==' '){i++;continue;}switch(str[i]){case '+':x=Pop(S)+Pop(S);i++;break;case'-':x=Pop(S);x=Pop(S)-x;i++;break;case'*':x=Pop(S)*Pop(S);i++;break;case'/':x=Pop(S);if(x!=0)x=Pop(S)/x;else{cerr<<"Divide by 0!"<<endl;exit(1);}i++;break;case'^':x=Pop(S);x=pow(Pop(S),x);i++;break;default:x=0;while(str[i]>=48&&str[i]<=57){x=x*10+str[i]-48;i++;}if(str[i]=='.'){i++;y=0;double j=10.0;while(str[i]>=48&&str[i]<=57){y=y+(str[i]-48)/j;i++;j*=10;}x+=y;}}Push(S,x);}if(EmptyStack(S)){cerr<<"expression error!"<<endl;exit(1);}x=Pop(S);if(EmptyStack(S))return x;else{cerr<<"expression error!"<<endl;exit(1);}ClearStack(S);}（注：可编辑下载，若有不当之处，请指正，谢谢!）。
数据结构实验二_栈的基本操作
青岛理工大学课程实验报告及实验步骤只要Ｘ不为０重复做下列动作将Ｘ％Ｒ入栈X=X/R只要栈不为空重复做下列动作栈顶出栈输出栈顶元素调试过程及实验结果根据输入的十进制数通过桟的基本操作可以转换成二进制、八进制、十六进制的数。
在上机过程中程序的调用没有太大的问题，按照课本的基本算法就可以将程序正确的运行。
总结程序可以完成基本的功能，可以将十进制数转换为其他进制的数，基本掌握了桟的几种常用的操作；但程序存在缺陷，就是不能持续进行操作，输入了一个十进制数只能进行一次数制转换，程序就会退出，有待改进。
附录#include <stdio.h>#include <stdlib.h>#include <malloc.h>#define stack_init_size 100#define stackincrement 10typedef struct sqstack{int *base;int *top;int stacksize;} sqstack;int StackInit(sqstack *s){s->base=(int *)malloc(stack_init_size *sizeof(int));if(!s->base)return 0;{return 0;}}int conversion(sqstack *s){int n,e=0,flag=0;printf("输入要转化的十进制数：\n");scanf("%d",&n);printf("要转化为多少进制：2进制、8进制、16进制填数字！\n");scanf("%d",&flag);printf("将十进制数%d转化为%d进制是：\n",n,flag);while(n){s->top=s->base;s->stacksize=stack_init_size;return 1;}int Push(sqstack *s,int e){if(s->top-s->base>=s->stacksize){s->base=(int*)realloc(s->base,(s->stacksize+stackincrement)*sizeof(int)); if(!s->base)return 0;s->top=s->base+s->stacksize;s->stacksize+=stackincrement;}*(s->top++)=e;return e;}int Pop(sqstack *s,int e){if(s->top==s->base)return 0;e=*--s->top;return e;}int stackempty(sqstack *s){if(s->top==s->base){return 1;}elsePush(s,n%flag);n=n/flag;}while(!stackempty(s)) {e=Pop(s,e);switch(e){case 10: printf("A");break;case 11: printf("B");break;case 12: printf("C");break;case 13: printf("D");break;case 14: printf("E");break;case 15: printf("F");break;default: printf("%d",e); }}printf("\n");return 0;}int main(){sqstack s;StackInit(&s); conversion(&s);return 0;}。
链栈的各种基本运算的实现实验报告
软件技术基础实验二----- 链栈的各种基本运算的实现班级：电信0901学号：0703090106姓名：蒋玮珂实验二链栈的各种基本运算的实现（1）实验题目：编写一个程序，实现链栈的各种基本运算，并在此基础上设计一个主程序完成如下功能：（1）初始化链栈（2）依次进栈元素a,b,c,d,e（3）输出从栈顶到栈底元素（4）判断链栈是否非空（2）实验目的：1.掌握栈的数据类型描述，栈的特点及栈的存储结构2.掌握栈的基本运算及应用（3）调试通过并正确执行给定功能要求的实验代码:#include "stdafx.h"#include <iostream.h>#include <fstream.h>struct link{char data;link *next;};void inistack(link *top){top->next=NULL;}void push(link *top,char x){link *s;s=new link;s->data=x;s->next=top->next;top->next=s;}char pop(link *top){link *s;s=top->next;if(s!=NULL){top->next=s->next;return(s->data);delete(s);}else{return(NULL);}}char gettop(link *top){if(top->next!=NULL) return(top->next->data);else return(NULL);}int empty(link *top){if(top->next==NULL) return(1);else return(0);}void main(){link *top;char x,out1;int i=1;ifstream infile("E:\\Program Files\\MSDev98\\MyProjects\\jwk1\\jwk1.txt");ofstream outfile("E:\\Program Files\\MSDev98\\MyProjects\\jwk1\\jwk2.txt");top=new link;inistack(top);while(i<=5){infile>>x;push(top,x);i=i+1;}outfile<<"出栈序列:"<<endl;for(i=1;i<=5;i++){out1=pop(top);outfile<<out1<<endl;}if(empty(top))outfile<<"链栈已空"<<endl;elseoutfile<<"链栈未空"<<endl;infile.close();outfile.close();}（4）实验结果截图。
栈的基本操作实验报告
一、实验目的1. 掌握栈的定义、特点、逻辑结构，理解栈的抽象数据类型。
2. 熟练掌握顺序栈和链栈两种结构类型的定义、特点以及基本操作的实现方法。
3. 了解栈在解决实际问题中的应用。
二、实验内容1. 编写顺序栈和链栈的基本操作函数，包括入栈（push）、出栈（pop）、判断栈空（isEmpty）、获取栈顶元素（getTop）等。
2. 利用栈实现字符序列是否为回文的判断。
3. 利用栈实现整数序列中最大值的求解。
三、实验步骤1. 创建顺序栈和链栈的结构体，并实现相关的基本操作函数。
2. 编写一个函数，用于判断字符序列是否为回文。
该函数首先将字符序列中的字符依次入栈，然后逐个出栈，比较出栈的字符是否与原序列相同，若相同则表示为回文。
3. 编写一个函数，用于求解整数序列中的最大值。
该函数首先将序列中的元素依次入栈，然后逐个出栈，每次出栈时判断是否为当前栈中的最大值，并记录下来。
四、实验结果与分析1. 顺序栈和链栈的基本操作函数实现如下：```c// 顺序栈的基本操作void pushSeqStack(SeqStack s, ElemType x) {if (s->top < MAXSIZE - 1) {s->top++;s->data[s->top] = x;}}void popSeqStack(SeqStack s, ElemType x) {if (s->top >= 0) {x = s->data[s->top];s->top--;}}bool isEmptySeqStack(SeqStack s) {return s->top == -1;}ElemType getTopSeqStack(SeqStack s) {if (s->top >= 0) {return s->data[s->top];}return 0;}// 链栈的基本操作void pushLinkStack(LinkStack s, ElemType x) {LinkStack p = (LinkStack )malloc(sizeof(LinkStack)); if (p == NULL) {exit(1);}p->data = x;p->next = s->top;s->top = p;}void popLinkStack(LinkStack s, ElemType x) { if (s->top != NULL) {LinkStack p = s->top;x = p->data;s->top = p->next;free(p);}}bool isEmptyLinkStack(LinkStack s) {return s->top == NULL;}ElemType getTopLinkStack(LinkStack s) {if (s->top != NULL) {return s->top->data;}return 0;}```2. 判断字符序列是否为回文的函数实现如下：```cbool isPalindrome(char str) {SeqStack s;initStack(&s);int len = strlen(str);for (int i = 0; i < len; i++) {pushSeqStack(&s, str[i]);}for (int i = 0; i < len; i++) {char c = getTopSeqStack(&s);popSeqStack(&s, &c);if (c != str[i]) {return false;}}return true;}```3. 求解整数序列中最大值的函数实现如下：```cint getMax(int arr, int len) {LinkStack s;initStack(&s);int max = arr[0];for (int i = 0; i < len; i++) {pushLinkStack(&s, arr[i]);if (arr[i] > max) {max = arr[i];}}while (!isEmptyLinkStack(&s)) {popLinkStack(&s, &max);}return max;}```五、实验心得通过本次实验，我对栈的基本操作有了更深入的理解。
数据结构实验报告栈
数据结构实验报告：栈摘要：本实验报告旨在介绍栈这一重要的数据结构，以及在实际应用中的使用。
栈是一种先进后出（LIFO）的数据结构，在计算机科学中有着广泛的应用。
本报告将详细介绍栈的定义、基本操作以及应用实例，并根据实验结果进行分析和总结。
1. 引言栈是一种基于线性表的数据结构，具有后进先出（LIFO）的特性。
它可以通过两个基本操作来实现：push（入栈）将元素添加到栈顶，pop（出栈）将栈顶元素移除。
栈在计算机科学中被广泛应用，如函数调用、表达式求值、括号匹配等。
2. 栈的实现栈可以通过数组或链表来实现。
数组实现的栈称为顺序栈，链表实现的栈称为链式栈。
无论是哪种实现方式，都需要实现以下基本操作：- push(element): 将元素添加到栈顶。
- pop(): 移除栈顶元素并返回。
- top(): 返回栈顶元素的值。
- isEmpty(): 判断栈是否为空。
- isFull(): 判断栈是否已满（仅顺序栈需要实现）。
3. 栈的应用3.1 函数调用栈在函数调用中起着关键作用。
每当一个函数被调用时，当前函数的局部变量、返回地址等信息都会被压入栈中。
当函数执行完毕时，这些信息会从栈中弹出，继续执行上一级函数。
3.2 表达式求值栈常用于表达式求值，特别是中缀表达式的转换和计算。
通过将中缀表达式转换为后缀表达式，可以方便地进行计算。
栈可以临时存储运算符，并根据运算符的优先级进行弹出和计算。
3.3 括号匹配栈的一个重要应用是括号匹配。
通过遍历字符串，将左括号压入栈中。
每当遇到右括号时，如果栈顶元素是匹配的左括号，则弹出栈顶元素；否则，表示括号不匹配。
4. 实验结果与分析根据我们对栈的实现和应用进行的实验，以下是我们得到的结论：- 通过数组实现的顺序栈在空间上存在一定的限制，可能会出现栈溢出的情况。
- 通过链表实现的链式栈没有空间限制，可以动态地添加和删除元素。
- 栈在函数调用和表达式求值中展现出了高效的性能，并能够简化程序的设计。
栈的基本操作实验报告
栈的基本操作实验报告实验目的本实验旨在通过使用栈来实现基本的操作，包括入栈、出栈、查看栈顶元素以及判断栈是否为空。
实验原理栈是一种后进先出（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，所以输出为“栈不为空”。
实验总结通过本实验，我们学习了栈的基本操作，包括入栈、出栈、查看栈顶元素以及判断栈是否为空。
【电大本科数据结构实验报告】栈和队列的基本操作
实验报告（学科：数据结构）姓名__________________单位_______________________班级______________________实验名称：2.1 栈和队列的基本操作【问题描述】编写一个算法，输出指定栈中的栈底元素，并使得原栈中的元素倒置。
【基本要求】（1）正确理解栈的先进后出的操作特点，建立初始栈，通过相关操作显示栈底元素。
（2）程序中要体现出建栈过程和取出栈底元素后恢复栈的入栈过程，按堆栈的操作规则打印结果栈中的元素。
【实验步骤】（1）建立顺序栈SeqStack，存放测试数据；建立队列SeqQueue存放出栈数据；（2）建立InitStack、StackEmpty、StackFull、Pop、Push、GetTop函数用作顺序栈的基本操作；（3）建立InitQueue、QEmpty、Qfull、InQueue、OutQueue、ReadFront函数用作队列的基本操作；（4）建立主函数依次按序对子函数进行操作：InitStack初始化栈→Push压入数据→InitQueue初始化队列→Pop弹出数据→InQueue存入队列→OutQueue出队列→Push压入栈→Pop弹出数据→free清空栈与队列。
在数据的输入与数据的输出时提供必要的提示信息。
（5）使用Visual Studio C++ 2005语言环境进行调试，源代码P202-2-1.cpp通过编译生成目标文件P202-2-1.obj，运行可执行文件：实验2-2-1.exe测试通过。
【源代码】#include "stdio.h"#include "stdlib.h"#define MaxSize 8typedef int ElemType;/*顺序栈的类型定义*/struct SeqStack{ElemType data[MaxSize];int top;};struct SeqStack * s;/*顺序队列的类型定义*/struct SeqQueue{ElemType data[MaxSize];int front,rear;};struct SeqQueue * sq;/*栈的基本运算*//*初始化栈操作*/void InitStack(struct SeqStack * s){s->top=-1;}/*判断栈空操作*/int StackEmpty(struct SeqStack * s){if(s->top==-1){ return(1);}else{return(0);}}/*判断栈满操作*/int StackFull(struct SeqStack * s){if(s->top==MaxSize-1){ return(1);}else{ return(0);}}/*压栈操作*/void Push(struct SeqStack *s,ElemType x) {if(s->top==MaxSize-1){printf("栈满溢出错误!\n");exit(1);}s->top++;s->data[s->top]=x;}/*弹栈操作*/ElemType Pop(struct SeqStack * s){if(StackEmpty(s)){printf("栈下溢错误!!\n");return(1);}s->top--;return s->data[s->top+1];}/*获取栈顶元素操作*/ElemType GetTop(struct SeqStack * s){if(StackEmpty(s)){printf("栈下溢错误!\n");exit(1);}return s->data[s->top];}/*队列的基本运算*//*初始化队列*/void InitQueue(struct SeqQueue * sq){sq->front=0;sq->rear=0;}/*判队空*/int QEmpty(struct SeqQueue * sq){if(sq->front==sq->rear){printf("队列已空，不能进行出队操作!\n");return(1); /*如果链队为空，则返回*/}else{return(0); /*否则返回*/ };}/*判队满*/int Qfull(struct SeqQueue * sq){if(sq->rear==MaxSize){ /*判队列是否已满*/printf("队列已满!\n");return(1); /*入队失败，退出函数运行*/ }return(0);}/*入队列操作*/void InQueue(struct SeqQueue * sq, int x){if(!Qfull(sq)){sq->data[sq->rear]=x; /*数据送给队尾指针所指单元*/sq->rear++; /*将队尾指针加*/ }}/*出队列操作*/ElemType OutQueue(struct SeqQueue *sq){if(sq->rear==sq->front){ /*判断队列是否为空*/printf("队列已空，不能进行出队操作!!\n");return(1); /*出队失败，退出函数运行*/ }sq->front++;return sq->data[sq->front-1];}/*读队头元素*/void ReadFront(struct SeqQueue * sq,int x){if(!QEmpty(sq)){sq->front++; /*将头指针加,前移*/OutQueue(sq); /*出队列操作*/ }}void main(){int n;struct SeqStack *a=(SeqStack *)malloc(sizeof(struct SeqStack));/*分配栈的内存空间，使结构指针a指向栈地址*/struct SeqQueue *sq=(SeqQueue *)malloc(sizeof(struct SeqQueue));InitStack(a);do{printf("输入栈中的数据:");scanf("%d",&n);Push(a,n);/*把数据压入栈中*/}while(!StackFull(a));InitQueue(sq);do{InQueue(sq,Pop(a)); /*弹出栈数据，把数据放进队列中*/}while(!(StackEmpty(a)&&Qfull(sq)));do{Push(a,OutQueue(sq)); /*从队列输出数据，把数据压入到栈内*/}while(!(QEmpty(sq)&&StackFull(a)));do{printf("输出栈中的数据:%d\n",Pop(a)); /*弹出栈中所有数据*/ }while(!StackEmpty(a));free(a);free(sq);}【实验数据】【结论】由于栈的结构特点决定了栈对数据的操作规则。
栈实验报告实验结论
实验目的：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篇一、实验背景栈（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）判断栈空操作用于判断栈是否为空。
C语言数据结构之栈的基本操作
C语言数据结构之栈的基本操作栈是一种特殊的数据结构，它按照后进先出（LIFO）的原则进行操作。
栈可以用数组或链表来实现，下面将介绍栈的基本操作。
1.初始化栈：栈的初始化就是为栈分配内存空间，并将栈顶指针设置为-1（如果是数组实现）或者NULL（如果是链表实现）。
2.判断栈空：栈空表示栈中没有任何元素。
如果栈顶指针等于-1或者NULL，则表示栈空。
3.判断栈满：栈满表示栈中已经存满了元素。
如果栈顶指针等于栈的最大容量减1，则表示栈满。
4. 进栈（push）：进栈操作就是将元素放入栈中。
如果栈不满，则将栈顶指针加1，并将元素放入栈顶位置。
5. 出栈（pop）：出栈操作就是从栈中取出一个元素。
如果栈不空，则将栈顶指针减1，并返回栈顶元素。
6. 获取栈顶元素（getTop）：获取栈顶元素操作不改变栈的状态，只返回栈顶元素的值。
如果栈不空，则返回栈顶元素值；否则，返回空值。
7.清空栈：清空栈操作就是将栈中的所有元素全部出栈，即将栈顶指针设置为-1或者NULL。
8.销毁栈：销毁栈操作是释放栈的内存空间，将栈的指针设置为NULL。
栈的应用：栈在计算机领域有广泛的应用，其中一个常见的应用是函数调用栈。
当一个函数调用另一个函数时，当前函数的状态（包括局部变量、返回地址等）会被压入到栈中。
当被调用函数执行完成后，栈顶的元素会被弹出，然后继续执行调用该函数的代码。
另一个常见的应用是表达式求值。
在表达式求值过程中，需要用到运算符优先级。
我们可以利用栈来处理运算符的优先级。
将运算符入栈时，可以先与栈顶运算符比较优先级，如果栈顶运算符的优先级高于当前运算符，则将栈顶运算符出栈，并继续比较。
这样可以确保栈中的运算符按照优先级从高到低的顺序排列。
此外，栈还可以用于处理括号匹配问题。
当遇到左括号时，将其入栈；当遇到右括号时，判断栈顶元素是否为对应的左括号，如果是，则将栈顶元素弹出，否则表示括号不匹配。
如果最后栈为空，则表示所有括号都匹配。
栈的应用实验报告
栈的应用实验报告栈的应用实验报告引言：栈是一种常见的数据结构，它具有后进先出（Last In First Out，LIFO）的特点。
在计算机科学中，栈被广泛应用于各种领域，如编译器、操作系统、图形处理等。
本实验旨在通过实际应用场景，探索栈的应用。
一、栈的基本概念和操作栈是一种线性数据结构，它由一系列元素组成，每个元素都有一个前驱元素和一个后继元素。
栈的基本操作包括入栈（Push）和出栈（Pop）。
入栈将元素添加到栈的顶部，而出栈则将栈顶元素移除。
此外，栈还具有查看栈顶元素（Top）和判断栈是否为空（IsEmpty）的操作。
二、栈在表达式求值中的应用栈在表达式求值中发挥着重要作用。
例如，当我们需要计算一个数学表达式时，可以通过将表达式转换为后缀表达式，并利用栈来进行求值。
栈中存储操作数，当遇到运算符时，从栈中弹出相应数量的操作数进行计算，再将结果入栈。
通过这种方式，我们可以实现高效的表达式求值。
三、栈在函数调用中的应用栈在函数调用中也扮演着重要角色。
当我们调用一个函数时，计算机会将函数的返回地址、参数和局部变量等信息存储在栈中。
这样，当函数执行完毕后，可以从栈中恢复之前的上下文，继续执行调用函数的代码。
栈的这种特性使得递归函数的实现成为可能，同时也为程序的模块化提供了便利。
四、栈在迷宫求解中的应用栈在迷宫求解中也能发挥重要作用。
当我们需要找到从起点到终点的路径时，可以利用栈来存储当前路径上的位置。
从起点开始，我们按照某种策略选择下一个位置，并将其入栈。
如果当前位置无法继续前进，则将其出栈，并选择下一个位置。
通过不断重复这个过程，直到找到终点或者栈为空，我们就能得到迷宫的解。
五、栈在撤销和恢复操作中的应用栈在撤销和恢复操作中也能发挥重要作用。
当我们在编辑文档或者绘图时，经常需要进行撤销和恢复操作。
栈可以用来记录每次操作的状态，当用户选择撤销时，从栈中弹出最近的操作，并将文档或图形恢复到之前的状态。
通过这种方式，我们可以提供良好的用户体验，同时也方便用户进行操作的回溯。
实现顺序栈的各种基本运算的算法实验原理
实现顺序栈的各种基本运算的算法实验原理一、引言顺序栈是一种常见的数据结构，它的特点是栈中元素的存储是连续的。
顺序栈的基本运算包括入栈、出栈、判空和获取栈顶元素等。
本文将详细介绍实现顺序栈各种基本运算的算法实验原理。
二、顺序栈的定义顺序栈是由一个一维数组和一个栈顶指针组成的数据结构。
栈顶指针指向栈顶元素的位置，当栈为空时，栈顶指针为-1；当栈满时，栈顶指针等于数组的长度减1。
三、顺序栈的入栈操作入栈操作是将一个元素压入栈中。
具体步骤如下：1. 判断栈是否已满，如果满则提示栈已满，无法进行入栈操作；2. 栈顶指针加1；3. 将待入栈的元素存入栈顶指针所指向的位置。
四、顺序栈的出栈操作出栈操作是将栈顶元素删除并返回。
具体步骤如下：1. 判断栈是否为空，如果为空则提示栈已空，无法进行出栈操作；2. 获取栈顶元素的值；3. 栈顶指针减1。
五、顺序栈的判空操作判空操作是判断栈是否为空。
具体步骤如下：根据栈顶指针的值来判断，如果栈顶指针为-1，则表示栈为空，否则表示栈非空。
六、顺序栈的获取栈顶元素操作获取栈顶元素操作是获取栈顶元素的值，但不删除。
具体步骤如下：1. 判断栈是否为空，如果为空则提示栈已空，无法获取栈顶元素；2. 获取栈顶元素的值。
七、顺序栈的算法实现下面以C语言为例，给出顺序栈的算法实现：1. 定义顺序栈的数据结构typedef struct {int top; // 栈顶指针int maxSize; // 栈的最大容量int* data; // 栈的数据存储区} SeqStack;2. 初始化顺序栈void initStack(SeqStack* stack, int maxSize) {stack->top = -1;stack->maxSize = maxSize;stack->data = (int*)malloc(maxSize * sizeof(int)); }3. 入栈操作void push(SeqStack* stack, int value) {if (stack->top == stack->maxSize - 1) {printf("栈已满，无法进行入栈操作\n");return;}stack->top++;stack->data[stack->top] = value;}4. 出栈操作int pop(SeqStack* stack) {if (stack->top == -1) {printf("栈已空，无法进行出栈操作\n");return -1;}int value = stack->data[stack->top];stack->top--;return value;}5. 判空操作int isEmpty(SeqStack* stack) {return stack->top == -1;}6. 获取栈顶元素操作int top(SeqStack* stack) {if (stack->top == -1) {printf("栈已空，无法获取栈顶元素\n");return -1;}return stack->data[stack->top];}八、实验原理1. 实验目的：通过实现顺序栈的各种基本运算，加深对顺序栈的理解，并掌握顺序栈的操作原理和算法实现。
关于栈的实验报告
关于栈的实验报告引言栈（Stack）是一种常用的数据结构，它基于后进先出（Last In First Out，LIFO）的原则，元素的插入和删除操作只能在栈顶进行。
栈具有快速插入和删除元素的特点，因此在很多应用中广泛使用。
本实验旨在通过编写一个栈的实现，探究栈的基本操作以及应用，并对栈的性能进行评估。
一、栈的实现1. 栈的定义使用数组来实现一个基本的栈结构，可以定义一个栈类`Stack`，其中包含以下属性和方法：- 属性：- `max_size`：栈的最大容量- `top`：栈顶指针- `data`：存储栈元素的数组- 方法：- `__init__(self, size)`：构造函数，初始化栈对象，参数为栈的最大容量- `is_empty(self)`：判断栈是否为空- `is_full(self)`：判断栈是否已满- `push(self, item)`：将元素压入栈顶- `pop(self)`：从栈顶弹出一个元素- `peek(self)`：返回栈顶元素- `size(self)`：返回栈的当前大小- `clear(self)`：清空栈中所有元素2. 栈的实现pythonclass Stack:def __init__(self, size):self.max_size = sizeself.top = -1self.data = [None] * sizedef is_empty(self):return self.top == -1def is_full(self):return self.top == self.max_size - 1 def push(self, item):if self.is_full():print("Stack is full.")returnself.top += 1self.data[self.top] = itemdef pop(self):if self.is_empty():print("Stack is empty.")return Noneitem = self.data[self.top]self.top -= 1return itemdef peek(self):if self.is_empty():print("Stack is empty.")return Nonereturn self.data[self.top]def size(self):return self.top + 1def clear(self):self.top = -1上述代码实现了一个基本的栈，其中使用一个列表`data` 来存储栈的元素，`top` 表示栈顶指针，初始值为-1。
《数据结构》课程实验实训报告--堆栈和队列的基本操作。
if(StackTop(myStack,&x)==0)
{
printf("error!\n");
return;
}
else
printf("The element of local top is :%d\n",x);
printf("The sequence of outing elements is:\n");
(*head)->next = NULL;
}/*判非空操作：*/
int StackNotEmpty(LSNode *head) /*判堆栈是否非空，非空返回1；空返回0*/
{
if(head->next == NULL) return 0; else return 1;
}/*入栈操作：*/
int StackPush(LSNode *head, DataType x) /*把数据元素x插入链式堆栈head的栈顶作为新的栈顶*/ { LSNode *p; if((p = (LSNode *)malloc(sizeof(LSNode))) == NULL) { printf("内存空间不足无法插入! \n"); return 0; } p->data = x; p->next = head->next; /*新结点链入栈顶*/ head->next = p; /*新结点成为新的栈顶*/ return 1; } /*出栈操作：*/
依次把5个元素入栈然后出栈并在屏幕上显示出栈的数据元对顺序循环队列常规的方法是使用队尾指针和队头指针队尾指针用于指示当前的队尾位置下标队头指针用于指示当前的队头位置下标
《数据结构》课程实验实训报告
栈的算法实验报告
一、实验目的1. 理解栈的基本概念和特点，掌握栈的抽象数据类型。
2. 掌握顺序栈和链栈的存储结构及其基本运算实现。
3. 熟练运用栈解决实际问题，如判断字符序列是否为回文、栈内容逆序等。
4. 了解递归算法中栈的状态变化，初步掌握递归的应用。
二、实验内容1. 实现一个判断字符序列是否为回文的算法。
2. 设计一个利用栈操作进行栈内容逆序的算法。
3. 实现一个求解整数数组最大值的递归算法。
三、实验过程1. 判断字符序列是否为回文（1）算法思想：使用栈结构存储字符序列，从序列两端分别遍历，将左端字符压入栈中，将右端字符与栈顶元素进行比较，若相等，则移动指针，继续比较；若不相等，则序列不是回文。
（2）代码实现：```c#include <stdio.h>#include <stdbool.h>#define MAX_SIZE 100typedef struct {char data[MAX_SIZE];int top;} Stack;bool initStack(Stack s) {s->top = -1;return true;}bool isEmpty(Stack s) {return s->top == -1;}bool push(Stack s, char x) {if (s->top >= MAX_SIZE - 1) {return false;}s->data[++s->top] = x;return true;}char pop(Stack s) {if (s->top == -1) {return '\0';}return s->data[s->top--];}bool isPalindrome(char str) {Stack s;initStack(&s);for (int i = 0; str[i] != '\0'; i++) {push(&s, str[i]);}while (!isEmpty(&s)) {if (str[i] != pop(&s)) {return false;}i--;}return true;}int main() {char str[] = "abba";if (isPalindrome(str)) {printf("The string is a palindrome.\n");} else {printf("The string is not a palindrome.\n");}return 0;}```2. 利用栈操作进行栈内容逆序（1）算法思想：使用一个临时栈，将原栈中的元素依次弹出，并压入临时栈中，最后将临时栈中的元素依次压回原栈，实现栈内容逆序。
顺序栈基本操作实验报告【精选文档】
数据结构实验三课程数据结构实验名称顺序栈基本操作第页专业班级学号姓名实验日期：年月日评分一、实验目的1．熟悉并能实现栈的定义和基本操作。
2．了解和掌握栈的应用。
二、实验要求1．进行栈的基本操作时要注意栈”后进先出"的特性。
2．编写完整程序完成下面的实验内容并上机运行。
3．整理并上交实验报告。
三、实验内容1．编写程序任意输入栈长度和栈中的元素值,构造一个顺序栈，对其进行清空、销毁、入栈、出栈以及取栈顶元素操作。
2．编写程序实现表达式求值，即验证某算术表达式的正确性,若正确,则计算该算术表达式的值。
主要功能描述如下:（1）从键盘上输入表达式。
（2）分析该表达式是否合法:•a) 是数字，则判断该数字的合法性。
若合法，则压入数据到堆栈中。
•b）是规定的运算符，则根据规则进行处理。
在处理过程中，将计算该表达式的值.•c) 若是其它字符,则返回错误信息。
（3）若上述处理过程中没有发现错误，则认为该表达式合法，并打印处理结果。
程序中应主要包含下面几个功能函数：•l void initstack（):初始化堆栈•l int Make_str（)：语法检查并计算•l int push_operate（int operate):将操作码压入堆栈•l int push_num（double num):将操作数压入堆栈•l int procede(int operate）:处理操作码•l int change_opnd（int operate)：将字符型操作码转换成优先级•l int push_opnd(int operate)：将操作码压入堆栈•l int pop_opnd（)：将操作码弹出堆栈•l int caculate(int cur_opnd）：简单计算+,—,＊，/•l double pop_num（）：弹出操作数四、实验步骤（描述实验步骤及中间的结果或现象。
在实验中做了什么事情，怎么做的，发生的现象和中间结果）第一题:＃include 〈iostream>using namespace std；#define STACK_INIT_SIZE 100 //存储空间初始分配量＃define STACKINCREMENT 10 //存储空间分配增量＃define OVERFLOW —1＃define OK 1＃define NO —1#define NULL 0typedef int Status;typedef char SElemType；typedef struct｛SElemType *base；//在栈构造之前和销毁之后，base的值为NULLSElemType *top; //栈顶指针int stacksize；//当前已分配的存储空间,以元素为单位｝SqStack；Status Initstack(SqStack ＆S）//构造一个空栈S{S。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
*******************************实验题目：栈的基本运算实验者信息：班级13007102，姓名庞文正，学号1300710226实验完成的时间3：00******************************一、实验目的1，掌握栈的各种存储结构及基本运算的实现。
2，掌握堆栈后进先出的运算原则在解决实际问题中的应用。
3，复习c语言中相关语句及函数的用法。
二、实验内容括号配对检查。
试设计一个程序对任意输入的语句或数学表达式，判断其括号是否匹配。
若匹配，则返回1，否则返回0。
调试程序并对相应的输出作出分析；修改输入数据，预期输出并验证输出的结果。
加深对算法的理解。
三、算法设计与编码1.本实验用到的理论知识总结本实验用到的理论知识，实现理论与实践相结合。
总结尽量简明扼要，并与本次实验密切相关，最好能加上自己的解释。
2.算法概要设计给出实验的数据结构描述，程序模块、功能及调用关系首先建立一个栈结构，且初始化栈为空。
然后由键盘上随即输入一个带括号的语句或带括号的数学表达式，同时将它们保存在一个字符型数组exps[]中。
扫描表达式exps,当遇到“(”、“[”、“{”时，将其入栈。
遇到“）”、“]”、“}”时，判断栈顶是否有相匹配的括号。
若没有，则退出扫描过程，返回0，否则直到exps扫描完毕为止。
若top为0，则返回1。
#include<stdio.h>#define MAXSIZE 100#define TRUE 1#define FALSE 0typedef int datatype;typedef struct //顺序栈的结构体定义{datatype stack[MAXSIZE];int top;}seqstack;void setnull(seqstack *s) //置空栈-由于c语言的数组下标是从0开始的，所以置{s->top=-1;} // {s->top=-1;} 空栈操作时将栈顶指针放在下标为0之前，即-1处。
int empty(seqstack *s) /*判断当前栈是否为空栈*/{if(s->top<0)return TRUE;elsereturn FALSE;}int push(seqstack *s,datatype x) /*把元素x压入栈s中*/{if(s->top>=MAXSIZE-1){printf("stack overflow!\n"); /*发生上溢*/return FALSE;}else{s->stack[++s->top]=x; /*栈顶指针上移，数据元素入栈*/return TRUE;}}datatype pop(seqstack *s) /*弹出当前栈s的栈顶元素*/{if(s->top<0){printf("stack empty!\n"); /*栈空，返回空值*/return -1;}else{s->top--;return(s->stack[s->top+1]);}//由于return语句的特点，必须先使top减1，然后再执行return语句。
而此} // 时栈顶元素的表示应该为s->top+1.int judge(seqstack *s) //括号匹配检查算法。
--遇到"("、"["、"{"时,{ // 将其压栈s中。
datatype symb,ch,store;push(s,'#');symb=getchar();/*从键盘接受字符*/ while(symb!='#'){switch(symb){case '(':case '[':case '{':push(s,symb);break;case ')':ch=pop(s);if(ch!='(') return FALSE;break;case ']':ch=pop(s);if(ch!='[') return FALSE;break;case '}':ch=pop(s);if(ch!='{') return FALSE;break;default: ;}symb=getchar();}if(pop(s)=='#') return TRUE;else return FALSE;}int jinzhishuchu(seqstack *s){int x,symb;scanf("%d",&symb);/*从键盘接受字符*/ while(symb!=0){push(s,symb%8);symb=symb/8;}while (!empty(s)){x=pop(s); //出栈操作printf("%d",x); //依次输出出栈结果}printf("\n");}main(){seqstack q;setnull(&q);printf("please input an express end with symbol '#':\n");if(judge(&q))printf("yes\n"); /*括号匹配，则输出yes*/elseprintf("no\n"); /*括号不匹配，则输出no*/jinzhishuchu(&q);}四、运行与测试（1）在调试程序的过程中遇到什么问题，是如何解决的？答：遇到很多括号不匹配（2）设计了那些测试数据？测试结果是什么？（3）程序运行的结果如何？成功运行！1、预习思考题调试好上述程序后，试着完成以下拓展内容：（1）假定表达式不是通过getchar()函数一个个传送的，而是存放在一个字符数组A[n]中，程序需要做哪些改变？将while改为for（i=0;i<=strlen(A[n]);i++）{switch(A[i]){case '(':case '[':case '{':push(s,symb);break;case ')':ch=pop(s);if(ch!='(') return FALSE;break;case ']':ch=pop(s);if(ch!='[') return FALSE;break;case '}':ch=pop(s);if(ch!='{') return FALSE;break;default: ;}}（2）在judge()函数中，如果不用switch()函数，你会怎么处理？用if替代if(symb=='(' || symb=='{' || symb=='['){push(s,symb);}if(symb==')'){ch=pop(s);if(ch!='(') return FALSE;}if(symb=='}'){ch=pop(s);if(ch!='{') return FALSE;}if(symb==']'){ch=pop(s);if(ch!='[') return FALSE;}2、分析讨论题：数制转换问题是栈应用的一个典型实例。
将十进制数转换成其它进制的数有一种简单的方法：例：十进制转换成八进制：(66)10=(102)866/8=8 余 28/8=1 余 01/8=0 余 1结果为余数的逆序:102 。
如果用栈的算法来实现，怎样实现？其基本原理是什么？int jinzhishuchu(seqstack *s) //括号匹配检查算法。
--遇到"("、"["、"{"时,{int x,symb;scanf("%d",&symb);/*从键盘接受字符*/while(symb!=0){push(s,symb%8);symb=symb/8;}while (!empty(s)){x=pop(s); //出栈操作printf("%d",x); //依次输出出栈结果}printf("\n");}五、总结和心得实验完成后的总结和思考。
此次实验很顺利！。