数据结构实验报告 顺序栈基本操作 括号匹配检验
栈的实验报告结论(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. 理解顺序栈的定义、性质和基本操作。
2. 掌握顺序栈的顺序存储结构及其实现方法。
3. 熟练运用顺序栈解决实际问题，如进制转换、括号匹配等。
4. 提高编程能力和问题解决能力。
二、实验环境1. 操作系统：Windows 102. 编程语言：C语言3. 开发环境：Visual Studio三、实验内容1. 顺序栈的定义和性质2. 顺序栈的顺序存储结构及其实现3. 顺序栈的基本操作：入栈、出栈、判空、判满、取栈顶元素4. 顺序栈的应用：进制转换、括号匹配四、实验步骤1. 定义顺序栈的数据结构```c#define MAXSIZE 100 // 顺序栈的最大容量typedef struct {char data[MAXSIZE]; // 存储栈中元素的数据数组int top; // 栈顶指针} SeqStack;```2. 初始化顺序栈```cvoid InitStack(SeqStack S) {S->top = -1; // 初始化栈顶指针为-1，表示栈为空}```3. 判断栈是否为空```cint StackEmpty(SeqStack S) {return S.top == -1; // 栈顶指针为-1时，表示栈为空}```4. 判断栈是否满```cint StackFull(SeqStack S) {return S.top == MAXSIZE - 1; // 栈顶指针等于最大容量减1时，表示栈满}```5. 入栈操作```cvoid Push(SeqStack S, char x) {if (StackFull(S)) {printf("栈满\n");return;}S->data[++S->top] = x; // 将元素x压入栈顶}```6. 出栈操作```cchar Pop(SeqStack S) {if (StackEmpty(S)) {printf("栈空\n");return 0;}return S->data[S->top--]; // 返回栈顶元素，并将栈顶指针减1 }```7. 取栈顶元素```cchar GetTop(SeqStack S) {if (StackEmpty(S)) {printf("栈空\n");return 0;}return S.data[S.top]; // 返回栈顶元素}```8. 顺序栈的应用（1）进制转换```cvoid DecimalToBinary(SeqStack S, int num) {SeqStack binaryStack;InitStack(&binaryStack);while (num > 0) {Push(&binaryStack, (num % 2) + '0'); // 将余数压入栈中num /= 2;}printf("十进制数 %d 转换为二进制数为：", num);while (!StackEmpty(binaryStack)) {printf("%c", Pop(&binaryStack)); // 依次弹出栈中元素，得到二进制数}printf("\n");}```（2）括号匹配```cint BracketMatch(char str) {SeqStack stack;InitStack(&stack);for (int i = 0; i < strlen(str); i++) {if (str[i] == '(' || str[i] == '[' || str[i] == '{') {Push(&stack, str[i]); // 将左括号压入栈中} else if (str[i] == ')' || str[i] == ']' || str[i] == '}') {if (StackEmpty(stack)) {return 0; // 右括号多于左括号，不匹配}char top = Pop(&stack); // 弹出栈顶元素if ((str[i] == ')' && top != '(') || (str[i] == ']' &&top != '[') || (str[i] == '}' && top != '{')) {return 0; // 左右括号不匹配}}}return StackEmpty(stack); // 栈为空，表示括号匹配}```五、实验结果与分析1. 实验结果通过实验，成功实现了顺序栈的定义、性质、顺序存储结构、基本操作和应用。
括号匹配栈实验报告
一、实验目的本次实验旨在通过编写程序实现括号匹配功能，加深对栈数据结构原理的理解和应用。
通过实验，掌握栈的基本操作，如入栈、出栈、判断栈空等，并学会利用栈解决括号匹配问题。
二、实验原理1. 栈是一种后进先出（LIFO）的线性数据结构，它只允许在栈顶进行插入和删除操作。
2. 括号匹配问题是指在一个字符串中，判断左右括号是否成对出现，且对应匹配。
3. 在解决括号匹配问题时，可以使用栈来存储遇到的左括号，并在遇到右括号时进行匹配。
如果栈为空或括号不匹配，则判断为无效括号。
如果栈为空，表示括号匹配正确，否则表示不匹配。
三、实验内容1. 定义栈结构体，包括栈的最大容量、栈顶指针、栈底指针、栈元素数组等。
2. 编写栈的基本操作函数，如初始化、入栈、出栈、判断栈空等。
3. 编写括号匹配函数，利用栈实现括号匹配功能。
4. 编写主函数，接收用户输入的字符串，调用括号匹配函数进行判断，并输出结果。
四、实验步骤1. 定义栈结构体和栈的基本操作函数。
```c#define MAX_SIZE 100typedef struct {char data[MAX_SIZE];int top;} Stack;void InitStack(Stack s) {s->top = -1;}int IsEmpty(Stack s) {return s->top == -1;}void Push(Stack s, char x) {if (s->top == MAX_SIZE - 1) { return;}s->data[++s->top] = x;}char Pop(Stack s) {if (s->top == -1) {return '\0';}return s->data[s->top--];}```2. 编写括号匹配函数。
```cint BracketMatch(char str) {Stack s;InitStack(&s);while (str) {if (str == '(' || str == '[' || str == '{') {Push(&s, str);} else if (str == ')' || str == ']' || str == '}') {if (IsEmpty(&s)) {return 0; // 不匹配}char c = Pop(&s);if ((c == '(' && str != ')') || (c == '[' && str != ']') || (c == '{' && str != '}')) {return 0; // 不匹配}}str++;}return IsEmpty(&s); // 栈为空，匹配成功}```3. 编写主函数。
数据结构顺序栈验证实验报告
数据结构顺序栈验证实验报告实验报告：数据结构顺序栈验证⒈引言在计算机科学中，数据结构是研究组织和管理数据的一种方式。
顺序栈是一种经典的数据结构，它基于数组实现，具有后进先出（LIFO）的特性。
本实验旨在验证顺序栈的正确性和性能。
⒉实验目的本实验的主要目的包括：a) 实现顺序栈的基本操作，包括入栈、出栈、判断栈空、判断栈满等。
b) 验证顺序栈的正确性，包括对各种情况下栈操作的正确性验证。
c) 分析顺序栈的性能，包括时间复杂度和空间复杂度的分析。
⒊实验步骤本实验的步骤如下：a) 设计顺序栈的数据结构，包括栈的最大容量和栈顶指针等。
b) 实现顺序栈的初始化操作，包括创建栈、初始化栈顶指针等。
c) 实现顺序栈的入栈操作，将元素插入到栈顶。
d) 实现顺序栈的出栈操作，将栈顶元素移除。
e) 实现顺序栈的判断栈空操作，判断栈是否为空。
f) 实现顺序栈的判断栈满操作，判断栈是否已满。
g) 编写验证顺序栈正确性的测试用例，包括入栈、出栈、判断栈空、判断栈满等操作。
h) 分析顺序栈的时间复杂度和空间复杂度。
⒋实验结果经过测试，顺序栈的基本操作均能正确执行。
测试用例包括：a) 入栈操作的测试：依次入栈若干元素，再进行出栈操作，验证栈的正确性。
b) 出栈操作的测试：先进行入栈操作，再进行出栈操作，验证栈的正确性。
c) 判断栈空操作的测试：进行入栈和出栈操作后，进行判断栈空操作，验证栈的正确性。
d) 判断栈满操作的测试：进行入栈操作并使栈满后，进行判断栈满操作，验证栈的正确性。
⒌性能分析根据实验结果和分析数据，得出以下结论：a) 顺序栈的时间复杂度：●入栈操作的时间复杂度为O(1)。
●出栈操作的时间复杂度为O(1)。
●判断栈空操作的时间复杂度为O(1)。
●判断栈满操作的时间复杂度为O(1)。
b) 顺序栈的空间复杂度为O(n)，其中n为栈的最大容量。
⒍附件本实验报告涉及以下附件：a) 顺序栈的源代码文件。
b) 验证顺序栈正确性的测试用例文件。
实验报告栈序列匹配
颜真卿《祭侄文稿》技法特点一、《祭侄文稿》情感真挚《祭侄文稿》是由真挚感情浇灌出来的精品，是心灵的奏鸣曲，是哀极愤极的心声，是血和泪凝聚成的不朽巨制。
细观《祭侄文稿》犹可感受到作者悼念亡侄时的情感波动和思绪起伏。
首句，按祭文体例，记祭悼的时日和祭者的身份，此时作者情绪尚属平稳，行笔稍缓，行字中间有楷字，情态肃穆。
接下来是对季明的赞语：“惟尔挺生，夙标幼德。
宗庙瑚琏，阶庭兰玉。
每慰人心，方期戬谷。
”此处全用规范的行书，一字一顿，赞誉之情，缺憾之感，融于毫末。
至“父陷子死，巢倾卵覆。
天不悔祸，谁为荼毒?念尔遘残，百身何赎!呜呼哀哉”一段，心情已至激愤。
“父陷子死”四字，如高空坠石，使人感到如当空霹雳，轰脑塞胸；其余诸字如飞沙走石，那种失却臂膀之痛楚，天何以补人何以堪之无奈，溢于言表。
再至“抚念摧切，震悼心颜”八字，更如乱石崩云，惊涛裂岸，大痛大愤之情喷涌而出。
至18行“呜呼哀哉”，前三字连绵而出，昭示悲痛之情已达极点。
从第19行至篇末，仿佛再度掀起风暴，其愤难抑，其情难诉。
写到“首榇”两字时，前后左右写了又改，改了又写，仿佛置身于情感旋风（涡）之中。
长歌当哭，泣血哀恸，结尾处之“魂而有知，无嗟久客。
呜呼哀哉!尚飨!”则直如长江之水，迅疾奔放，一泻而下，大有江河决堤的磅礴气势。
令人触目惊心，撼魂震魄。
通观全篇，行文如泣如诉，如控如檄，运笔畅达痛快，使转精巧自然，气势雄壮，波澜起伏，时而沉郁痛楚，声泪俱下；时而低回掩抑，痛彻心肝，堪称动人心魄的浩然正气之作。
姜夔在《续书谱》中说：“观古人之书，每想见其挥运之时。
”面对此稿，谁都会为那苍劲的线条，雄浑的气势和天真烂漫的形式所吸引，让人观之不觉为倦，览之莫识其端。
《祭侄文稿》无愧是中国书法史上一部最具有抒情意识且成为惊天地泣鬼神“天下行书第二”的杰出作品。
二、《祭侄文稿》技法天成颜真卿的《祭侄文稿》，是他在悲痛万分之时，不思笔墨，直抒入怀，用笔干练飞扬，气势雄强豪迈。
数据结构-栈的实现之括号匹配检测
数据结构-栈的实现之括号匹配检测假设表达式中只允许两种括号：()、{}；正确表达顺序为：()或{}或({})或{({}{})}的形势；如{(}或(})或({)}的表达形势均不对。
算法的设计思想： 出现左括弧则进栈； 出现右括弧则⾸先检测栈是否为空， 若栈空则表明此右括弧多余，表达式不匹配。
否则和栈顶数据⽐较，若匹配则栈顶出栈。
否则表明表达式不匹配； 最后若栈空且没有做鱼右括弧则匹配正确，否则表明不匹配。
实现代码如下（Stack.h头⽂件为之前写的数据结构-栈的顺序结构中写的数组那个⽅法，⽤到了⾥⾯栈的结构和连个基本栈操作）1void Matching(char e[])2 {3 Stack S;4 InitStack(S);5 unsigned int i = 0, state = 1;6char z;7while((int)(i <= strlen(e)) && state && e[i] != '\0') //结束条件超出数组长度或state为0或字符串结束8 {9switch(e[i])10 {11case'(':12case'{':13 Push(S,e[i]); //遇到({则进栈14 i++;15break;16case')':17 GetTop(S,z);18if(!StackEmpty(S) && z == '(') //遇到)则判断栈顶是不是(，是的话出栈，不是则不匹配19 {20 Pop(S,z);21 i++;22 }23else24 state = 0;25break;26case'}':27 GetTop(S,z);28if(!StackEmpty(S) && z == '{')//遇到}则判断栈顶是不是{，是则出栈，不是则不匹配29 {30 Pop(S,z);31 i++;32 }33else34 state = 0;35break;36 }37 }38if(StackEmpty(S) && state) //空栈且state不为0则全部匹配39 printf("括号全部匹配");40else41 printf("括号不匹配");42 }主函数测试代码如下：1void main()2 {3char e[20];4 printf("请输⼊括号:");5 scanf("%s",e);6 Matching(e);7 }测试只要输⼊表达式格式正确，则匹配结果是正确的。
数据结构实验6报告
数据结构实验报告第 6 次实验一、实验目的1．理解栈是操作受限（插入push, 删除pop）的线性表, 受限的是插入删除的位置。
2．在链式存储结构下实现：StackEmpty, Push,Pop, 几个基本操作。
3．通过调用基本操作实现括号匹配算法。
二、实验内容（问题）写一个算法, 识别依次读入的一个字符序列是否为形如‘序列1&序列2’模式的字符序列。
其中序列1和序列2中都不含字符‘&’, 且序列2是序列1的逆序列。
例如, ‘a+b&b+a’是属该模式的字符序列, 而’1+3&3-1’则不是。
测试数据: ’1+3&3-1’; ’a+b+c&c+b+a’; ’a+b+c&c+b’; ’b+c&c+b+a’;提示：利用栈 , 利用已实现的基本操作三、算法描述（给出自然语言描述的算法）1.向后依次扫描字符序列, 如果考察的字符不等于‘&’则入栈, 遇到‘&’则停止。
2.从‘&’后继续扫描, 考察字符的时候, 栈顶元素出栈, 若二者相等, 继续扫描；不等, 模式不成立。
3.扫描结束后, 栈空则模式成立四、详细设计（画流程图）五、程序代码#include<stdio.h>#include<stdlib.h>#define True 1#define False 0#define OK 1#define ERROR 0typedef int status;typedef char ElemType;typedef struct SNode{ElemType data;struct SNode *next;}SNode, *LinkStack;status InitStack(LinkStack &S);int StackEmpty(LinkStack S);status Push(LinkStack &S, ElemType e);status Pop(LinkStack &S, ElemType &e);status Is_Match(ElemType f[20]);main(){ElemType formula[20];int i;for(i=0;i<=3;i++){printf("\n请输入一个字符序列表达式: ");scanf("%s",formula);if(Is_Match(formula)==1) printf(" \n这个表达式符合‘序列1&序列2’模式！\n"); else printf("\n 这个表达式不符合‘序列1&序列2’模式！\n");}return(1);}status InitStack(LinkStack &S){S=NULL;return(OK);}int StackEmpty(LinkStack S){if(S==NULL) return(True);else return(False);}status Push(LinkStack &S, ElemType e){LinkStack p;p=(LinkStack)malloc(sizeof(SNode));if(!p) return(ERROR);p->data=e;p->next=S;S=p;return(OK);}status Pop(LinkStack &S, ElemType &e){LinkStack p;if(!S) return(ERROR);e=S->data;p=S;S=S->next;free(p);return(OK);}status Is_Match(ElemType f[20]){LinkStack St; ElemType *p,c;InitStack(St);p=f;for(;*p!='&';p++){ Push(St,*p);if(!Push(St, *p)) return(ERROR);}p++;for(;*p!='\0';p++){Pop(St,c);if(!Pop(St,c)) return(ERROR);else if(c!=*p) return(ERROR);}if(StackEmpty(St)) return(OK);else return(ERROR);}七、用户手册（教用户怎么用这个程序）用途: 判断字符串是否是“序列1&序列2’模式”用法：启动此程序, 屏幕会提示你输入数据, 输入数据并按下回车键即可。
数据结构实验报告栈
数据结构实验报告：栈摘要：本实验报告旨在介绍栈这一重要的数据结构，以及在实际应用中的使用。
栈是一种先进后出（LIFO）的数据结构，在计算机科学中有着广泛的应用。
本报告将详细介绍栈的定义、基本操作以及应用实例，并根据实验结果进行分析和总结。
1. 引言栈是一种基于线性表的数据结构，具有后进先出（LIFO）的特性。
它可以通过两个基本操作来实现：push（入栈）将元素添加到栈顶，pop（出栈）将栈顶元素移除。
栈在计算机科学中被广泛应用，如函数调用、表达式求值、括号匹配等。
2. 栈的实现栈可以通过数组或链表来实现。
数组实现的栈称为顺序栈，链表实现的栈称为链式栈。
无论是哪种实现方式，都需要实现以下基本操作：- push(element): 将元素添加到栈顶。
- pop(): 移除栈顶元素并返回。
- top(): 返回栈顶元素的值。
- isEmpty(): 判断栈是否为空。
- isFull(): 判断栈是否已满（仅顺序栈需要实现）。
3. 栈的应用3.1 函数调用栈在函数调用中起着关键作用。
每当一个函数被调用时，当前函数的局部变量、返回地址等信息都会被压入栈中。
当函数执行完毕时，这些信息会从栈中弹出，继续执行上一级函数。
3.2 表达式求值栈常用于表达式求值，特别是中缀表达式的转换和计算。
通过将中缀表达式转换为后缀表达式，可以方便地进行计算。
栈可以临时存储运算符，并根据运算符的优先级进行弹出和计算。
3.3 括号匹配栈的一个重要应用是括号匹配。
通过遍历字符串，将左括号压入栈中。
每当遇到右括号时，如果栈顶元素是匹配的左括号，则弹出栈顶元素；否则，表示括号不匹配。
4. 实验结果与分析根据我们对栈的实现和应用进行的实验，以下是我们得到的结论：- 通过数组实现的顺序栈在空间上存在一定的限制，可能会出现栈溢出的情况。
- 通过链表实现的链式栈没有空间限制，可以动态地添加和删除元素。
- 栈在函数调用和表达式求值中展现出了高效的性能，并能够简化程序的设计。
数据结构括号匹配实验报告
数据结构括号匹配实验报告括号的匹配1.需求和规格说明（1）实现括号的是否匹配的判定。
（2）实现匹配错误的提⽰。
（3）实现栈内容的动态显⽰。
2．设计2.1．设计思想（1）对于括号匹配的判定，⾸先输⼊字符串到缓冲区。
逐个字符读取字串，遇到的是左括号则⼊栈，若是右括号，则出栈。
出栈的左括号如果和右括号匹配，则⼀对括号匹配成功；否则，这对括号匹配失败，并给出错误提⽰。
（2）分析括号匹配错误出现的情况，主要有三种：左括号数⼤于右括号数，左括号与右括号不匹配，右括号数⼤于左括号数。
根据栈的存储情况就能判定出这三种情况，并且实时的将信息放映到可视化控件上。
（3）对于匹配过程和栈内容的动态显⽰，可以⽤listbox控件实时的显⽰和更新。
窗⼝上有两个listbox控件，第⼀个动态显⽰push和pop动作以及提⽰错误信息；第⼆个listbox则动态模拟栈内的存储情况。
2.2．设计表⽰(1)存储结构Node节点templateclass Node{public:element ele;Node *pre; //前驱指针Node *next; //后继指针Node(){pre=NULL;next=NULL;}Node(element e){ele=e;pre=NULL;next=NULL;}Node * MakeNode(element e)//传⼊参数返回⼀个节点指针，实现参数的封装。
{Node *temp=new Node(e); return temp;}};MyListStack链栈templateclass MyListStack{public:Node *base;Node *top;int index;MyListStack() //初始化链表{base=new Node();top=base;index=0;}void push(element n) //push {Node *temp=new Node(n); top->next=temp;temp->pre=top;top=temp;index++;}void pop(element & out) //pop {out=top->ele;top=top->pre;delete top->next;top->next=NULL;index--;}BOOL isEmpty(); //返回栈是否为空{if(index)return FALSE;elsereturn TRUE;}virtual ~MyListStack() //析构链栈，释放空间。
数据结构实验报告_栈(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。
数据结构实验——括号匹配的检验(附程序).
#include<stdio.h>#include<stdlib.h>typedef struct SNode{char data;struct SNode *next;}SNode,*Stack;typedef struct{Stack top;int length;}SqStack;//定义链式栈的结构体char InitStack(SqStack &S){S.top=NULL;S.length=0;return 0;}//初始化链式栈char Push(SqStack &S,char e) {Stack p;p=(Stack)malloc(sizeof(SNode)); if(!p)exit(0); p->data=e;p->next=S.top;S.top=p;S.length++;return 0;}//插入元素echar Pop(SqStack &S){if(!S.top)return 0;else{Stack q;q=S.top;S.top=S.top->next; --S.length;free(q);}return 0;}//删除栈顶元素echar main(){SqStack S;char w,e;InitStack(S);//初始化链式栈printf("提示：输入“ = ”表示输入表达式结束，程序将自动检查括号是否匹配\n\n\n");printf("请输入表达式：\n\n\n");scanf("%c",&w);printf("\n");printf("\n");while(w!='='){switch(w){case '(': Push(S,w);break;case '[': Push(S,w);break;case ')': if(!S.top)return 0;elsee=S.top->data; if(e=='(')Pop(S); break;case ']': if(!S.top)return 0;elsee=S.top->data; if(e=='[')Pop(S); break;default: break;}scanf("%c",&w);}if(S.top==NULL)printf("输入括号匹配\n");else printf("输入括号不匹配，请检查后重新输入\n");return 0;}。
括号匹配检测实验报告
括号匹配检测实验报告本实验旨在设计和实现一个括号匹配检测算法，检测给定字符串中的括号是否正确匹配。
实验原理：括号匹配检测是一种常见的算法问题。
其基本原理是利用栈（Stack）数据结构进行括号的匹配。
当遇到左括号时，将其入栈；当遇到右括号时，判断栈顶元素是否与其对应的左括号相匹配，若匹配则将栈顶元素出栈，继续检测下一个字符；若不匹配，则说明括号不正确匹配，返回匹配失败；最后，若栈为空，则说明所有括号都正确匹配，返回匹配成功。
实验步骤：1. 设计栈数据结构及括号匹配检测算法。
2. 实现算法代码。
3. 设计测试用例，包括正确匹配和不正确匹配的字符串。
4. 运行测试用例，检测算法的正确性和效率。
5. 分析实验结果并撰写实验报告。
实验代码：以下是一个用Python语言实现的括号匹配检测算法示例代码：pythonclass Stack:def __init__(self):self.stack = []def is_empty(self):return len(self.stack) == 0def push(self, element):self.stack.append(element)def pop(self):if not self.is_empty():return self.stack.pop()else:return Nonedef peek(self):if not self.is_empty():return self.stack[-1]else:return Nonedef bracket_match(string):stack = Stack() # 创建栈对象brackets = {'(': ')', '[': ']', '{': '}'}for char in string:if char in brackets: # 左括号入栈stack.push(char)elif char in brackets.values(): # 右括号与栈顶元素匹配if stack.is_empty():return Falseif brackets[stack.peek()] == char:stack.pop()else:return Falsereturn stack.is_empty()# 测试用例test_cases = ["()", "{[]}", "[{()}]", "(}", "{[}]"]for test_case in test_cases:if bracket_match(test_case):print(test_case, "匹配成功")else:print(test_case, "匹配失败")实验结果：运行测试用例，可以得到以下结果：- "()" 匹配成功- "{[]}" 匹配成功- "[{()}]" 匹配成功- "(}" 匹配失败- "{[}]" 匹配失败实验讨论：根据实验结果，我们可以看到算法能够正确地检测出括号的匹配情况。
数据结构顺序栈验证实验报告
/// <summary> /// 十进制转换为八进制 /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void radio_dto_Click_1(object sender, EventArgs e) {
MessageBox.Show("请输入合法的十进制数", "提示", MessageBoxButtons.OK, MessageBoxIcon.Warning); } } else { MessageBox.Show("请提供转换数据!", "提示", MessageBoxButtons.OK, MessageBoxIcon.Warning); } txtStart.Focus(); } /// <summary> /// 十进制转换为二进制 /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void radio_dtb_Click(object sender, EventArgs e) { txtEnd.Text = ""; if (txtStart.Text.Length != 0) { // TODO: 十进制转换为二进制。 Int32 i; try { i = Convert.ToInt32(txtStart.Text.Trim()); lblTitle.Text = "十进制转换为二进制"; txtEnd.Text = Convert.ToString(i, 2); } catch { MessageBox.Show("请输入合法的十进制数", "提示", MessageBoxButtons.OK, MessageBoxIcon.Warning); } } else { MessageBox.Show("请提供转换数据!", "提示", MessageBoxButtons.OK, MessageBoxIcon.Warning); } txtStart.Focus(); } /// <summary>
括号匹配实验报告
括号匹配实验报告实验报告课程名称：数据结构班级：实验成绩：实验名称：栈、队列、字符串和数组学号：批阅教师签字：实验编号：实验⼆姓名：实验⽇期：指导教师：组号：实验时间：⼀、实验⽬的（1）掌握栈、队列、串和数组的抽象数据类型的特征。
（2）掌握栈、队列、串和数组的抽象数据类型在计算机中的实现⽅法。
（3）学会使⽤栈、队列来解决⼀些实际的应⽤问题。
⼆、实验内容与实验步骤（1）实验内容：假设表达式中除了变量名、常量和运算符外，还可以允许两种括号：圆括号和中括号，其嵌套的次序随意，编写程序检验输⼊的表达式中括号的的顺序是否合法。
（2）描述抽象数据类型或设计的函数描述，说明为什么要使⽤这种抽象数据类型，并说明解决设想。
抽象数据类型或函数描述：⾸先定义了⼀个结构体并且声明为栈类型，在其中定义了空间基地址的指针、栈顶指针以及栈存储空间的⼤⼩。
之后设计了Creat _Stack的函数，⽤此函数来创建⼀个空栈，这样可以使⽤堆栈来实现括号匹配的功能，⼜设计了⼀个名为Stack_Full的函数了来判断栈是否已满，若栈未满才可继续之后的压栈功能，如果堆栈已满，则需要使⽤realloc来动态分配空间，扩⼤栈的存储空间。
我还设计了⼀个名为empty的函数，⽤它来判断堆栈是否为空，堆栈为空或不为空时分别返回0或1。
之后设计了名为push和pop的函数来实现括号的⼊栈和出栈，之后设计了名为Match的函数，来判断括号是否匹配，设计了名为clean的函数来清空堆栈，这样可以连续判断不同的多项式的括号是否匹配。
解决设想：对于本题，⾸先我使⽤了栈结构，利⽤栈中数据“先进后出”的特点来实现对括号是否匹配的检验。
实现过程基本如下：从左到右依次扫描多项式，如果遇到左括号便将左括号⼊栈，在所有左括号⼊栈之后便可以扫描到右括号，如果扫描到的右括号和栈顶的左括号可以匹配时，将左括号出栈，以此类推，最后判断栈是否为空，若为空，则括号匹配，否则括号不匹配。
括号匹配检测实验报告(3篇)
第1篇实验名称：括号匹配检测实验目的：1. 理解括号匹配的基本原理。
2. 掌握使用栈进行括号匹配检测的方法。
3. 通过编程实现括号匹配检测功能。
实验时间：2023年X月X日实验地点：实验室实验器材：1. 计算机2. 编程软件（如Python、Java等）3. 文档编辑器实验内容：一、实验原理括号匹配检测是计算机科学中的一个基础问题，它涉及到字符串中括号的正确配对。
常见的括号包括圆括号()、方括号[]和花括号{}。
一个有效的括号序列是指，序列中的每个左括号都有一个对应的右括号，并且括号内的内容可以嵌套。
括号匹配检测通常使用栈（Stack）这一数据结构来实现。
栈是一种后进先出（Last In First Out，LIFO）的数据结构，适用于括号匹配检测的原因是括号的匹配顺序与它们出现的顺序相反。
二、实验步骤1. 设计算法：确定使用栈进行括号匹配检测的算法步骤。
2. 编写代码：根据算法步骤，编写实现括号匹配检测功能的代码。
3. 测试代码：使用不同的测试用例对代码进行测试，确保其正确性。
4. 分析结果：对测试结果进行分析，评估代码的性能和正确性。
三、实验代码以下是一个使用Python实现的括号匹配检测的示例代码：```pythondef is_balanced(s):stack = []bracket_map = {')': '(', ']': '[', '}': '{'}for char in s:if char in bracket_map.values():stack.append(char)elif char in bracket_map.keys():if not stack or bracket_map[char] != stack.pop(): return Falsereturn not stack测试用例test_cases = ["((()))", True"([{}])", True"({[}])", False"((())", False"()[]{}", True"([)]", False"(({[]}))", True"" True]for case in test_cases:print(f"Input: {case}, Output: {is_balanced(case)}")```四、实验结果与分析通过上述代码，我们对一系列测试用例进行了括号匹配检测。
数据结构实验报告：括号匹配问题
●实验内容：利用栈的基本操作，写一个C程序实现检测表达式“@{（a+b）*[c-d]+e}+f”中的括号是否匹配。
●实验目的：掌握栈的操作●提交内容：C语言源代码：#include <stdio.h>#include <string.h>#define MaxSize 100typedef char ElemType;typedef struct{ElemType data[MaxSize];int top;}SeqStack;int InitStack(SeqStack *s){s->top=-1;return 1;}int Push(SeqStack *s,ElemType x){if (s->top == MaxSize -1 ){printf("栈已满,不能入栈.\n");return 0;}else{s->top++;s->data[s->top] = x;}return 1;}int Pop(SeqStack *s,ElemType *x) {if (s->top == -1){printf("栈为空,不能出栈.\n");return 0;}else{*x=s->data[s->top];s->top--;}return 1;}int GetTop(SeqStack *s,ElemType *x) {if (s->top == -1){printf("栈为空,不能取值.\n");return 0;}else{*x=s->data[s->top];}return 1;}int IsEmpty(SeqStack *s) {if(s->top==-1)return 1;return 0;}int Check(char str[],int len) {int i;int a=1,b=0;ElemType x;SeqStack s;InitStack(&s);for(i=0;i<len;i++){if(str[i]=='{'){if(IsEmpty(&s)){if(Push(&s,str[i])!=1){a=0;break;}}else{if(GetTop(&s,&x)!=1){a=0;break;}if(x=='{' || x=='[' || x== '('){a=0;break;}else{if(Push(&s,str[i])!=1){a=0;break;}}}}else if(str[i]=='['){if(IsEmpty(&s)){if(Push(&s,str[i])!=1){a=0;break;}}else{if(GetTop(&s,&x)!=1){a=0;break;}if(x=='[' || x== '('){a=0;break;}else{if(Push(&s,str[i])!=1){a=0;break;}}}}else if(str[i]=='('){if(Push(&s,str[i])!=1){a=0;break;}b=1;}else if(str[i]==')'){if(Pop(&s,&x)!=1){a=0;break;}if(x!='('){a=0;break;}}else if(str[i]==']'){if(Pop(&s,&x)!=1){a=0;break;}if(x!='['){a=0;break;}if(b==0){a=0;break;}}else if(str[i]=='}'){if(Pop(&s,&x)!=1){a=0;break;}if(x!='{'){a=0;break;}if(b==0){a=0;break;}}elsecontinue;}if(!IsEmpty(&s))a=0;return a;}int main(){char str[MaxSize];int i,len;printf("输入字符串:\n");gets(str);len=strlen(str);if(Check(str,len)==0)printf("匹配合法\n");elseprintf("匹配不合法\n");。
数据结构实验报告 顺序栈基本操作 括号匹配检验
三、实验内容
1．编写程序任意输入栈长度和栈中的元素值，构造一个顺序栈，对其进行清空、销毁、 入栈、出栈以及取栈顶元素操作。 2．编写程序实现表达式求值，即验证某算术表达式的正确性，若正确，则计算该算术 表达式的值。 主要功能描述如下： （1）从键盘上输入表达式。 （2）（2）分析该表达式是否合法： a) 是数字，则判断该数字的合法性。若合法，则压入数据到堆栈中。 b) 是规定的运算符，则根据规则进行处理。在处理过程中，将计算该表达式的值。 c) 若是其它字符，则返回错误信息。 （3）若上述处理过程中没有发现错误，则认为该表达式合法，并打印处理结果。 程序中应主要包含下面几个功能函数： void initstack()：初始化堆栈 int Make_str()：语法检查并计算 int push_operate(int operate)：将操作码压入堆栈 int push_num(double num)：将操作数压入堆栈 int procede(int operate)：处理操作码 int change_opnd(int operate)：将字符型操作码转换成优先级 int push_opnd(int operate)：将操作码压入堆栈 int pop_opnd()：将操作码弹出堆栈 int caculate(int cur_opnd)：简单计算+，-，*，/ double pop_num()：弹出操作数
-4-
{SElemType_num num; SElemType_op opr; }u; }uu[100]; typedef struct { SElemType_num *base; SElemType_num *top; int stacksize; }SqStack_num; typedef struct { SElemType_op *base; SElemType_op *top;
括号配对检验实验报告
括号配对检验实验报告实验目的本实验的目的是设计一个算法，用于检验一个字符串中的括号是否配对。
实验原理在数学、编程等领域，我们会经常使用括号来表示不同层次的结构。
但是在实际应用中，很容易出现括号的不配对错误，从而导致程序逻辑错误或结果不符合预期。
因此，设计一个算法来检验括号的配对情况是非常有意义的。
本实验使用栈的数据结构来实现括号配对的检验。
栈是一种具有后进先出（Last In First Out，简称LIFO）特点的数据结构，可以用于解决需要后操作的优先级问题。
当遍历字符串中的括号时，我们将左括号（例如“（”、“[”、“{”）压入栈中，当遇到右括号（例如“）”、“]”、“}”）时，我们将栈顶的元素弹出，并比较右括号与弹出的左括号是否匹配。
如果匹配，则继续遍历；如果不匹配，则返回“括号不配对”。
最后，如果栈为空，说明所有的括号都成功匹配，返回“括号配对”。
实验过程首先，我们需要实现一个栈数据结构。
栈可以使用数组或链表来实现，本实验选择使用数组来实现。
定义一个整数变量`top`，代表栈顶元素的索引；定义一个整数数组`stack`存储栈中的元素。
接下来，我们遍历输入字符串中的每个字符。
当遇到左括号时，将其压入栈中；当遇到右括号时，将栈顶元素弹出，并比较两个括号是否配对。
如果不配对，则返回“括号不配对”。
最后，如果栈为空，则返回“括号配对”；否则，返回“括号不配对”。
实验结果为了验证算法的正确性，我们对不同的字符串进行了测试，下面是实验结果：测试1输入字符串：`()`实验结果：括号配对测试2输入字符串：`({})`实验结果：括号配对测试3输入字符串：`((]`实验结果：括号不配对测试4输入字符串：`{[()]}`实验结果：括号配对测试5输入字符串：`{[()]})`实验结果：括号不配对实验结论通过测试结果可以看出，本实验设计的括号配对检验算法能够正确检测括号的配对情况。
算法的时间复杂度为O(n)，其中n为字符串的长度。
数据结构实验报告（二）栈的应用
数据结构实验报告（⼆）栈的应⽤实验说明数据结构实验⼆ 栈的实验——栈的简单应⽤⼀、实验⽬的通过本实验使学⽣了解栈的简单应⽤，熟悉栈的特性及栈在顺序存储上的操作特点，深刻理解栈的基本操作与⽤栈解决应⽤问题的关系；特别训练学⽣使⽤栈解决实际问题的能⼒，为今后⽤栈解决相关问题奠定基础。
⼆、实验内容1.编程实现对给定的⼀组括号序列判断其是否匹配正确。
要求：（1）它必须成对出现，如“(”“)”是⼀对，“[”与“]”是⼀对；（2）出现时有严格的左右关系；（3）可以以嵌套的⽅式同时出现多组多括号，但必须是包含式嵌套，不允许交叉式嵌套。
⽐如“( )”、“[([][])]”这样是正确的，“[(])”或“([()))”或 “(()]”是不正确的。
（4）将处理的括号扩展为针对“()”“[]”“{}”三类。
2.编程实现⼀个简单的⾏编辑功能：⽤户可以输⼊⼀⾏内容，并可进⾏简易编辑。
要求：（1）遇到输⼊部分内容有误时操作退格符“#”表⽰前⼀位⽆效；（2）“@”表⽰之前的内容均⽆效。
实验报告1.实现功能描述编程实现对给定的⼀组括号序列判断其是否匹配正确，将处理的括号扩展为针对“()”“[]”“{}”三类，遇到输⼊部分内容有误时操作退格符“#”表⽰前⼀位⽆效；“@”表⽰之前的内容均⽆效。
2.⽅案⽐较与选择（1）可以使⽤栈和队列来实现。
因为栈的功能⾜以完成题⽬要求，所以初步打算使⽤栈来实现。
（2）因为编写⼀个标准的栈⽐较繁琐，⽽且本题中也没有⽤到所有栈的标准操作，所以通过模拟栈来完成本题。
（3）可以使⽤数组或链表来模拟栈。
因为括号匹配只有3对，所需空间不是很⼤，⼜因为特殊操作#、@可以在数组中通过-1和赋0值实现，因此选择了数组法来模拟栈。
3.设计算法描述（1）定义3个变量，分别⽤于记录()、[]、{}的出现次数。
遇到左符号时变量++，遇到右符号时--，变量为0时表⽰空栈。
当读到#时，再往前读⼀个字符，如果是()、[]、{}中的⼀种，则对其进⾏反向运算，即遇到右符号时++，遇到左符号时--。
数据结构顺序栈验证实验报告
数据结构顺序栈验证实验报告数据结构顺序栈验证实验报告1·实验目的本实验旨在验证数据结构中顺序栈的基本操作是否正确，并通过实际案例应用来测试顺序栈的功能和性能。
2·实验背景顺序栈是一种常用的数据结构，它基于数组实现，具有先进后出的特性。
在实际应用中，顺序栈被广泛应用于计算机编译器、操作系统以及各种数据处理领域中。
为了确保顺序栈的正确性和稳定性，本实验将进行验证和测试。
3·实验环境3·1 硬件环境：计算机一台，内存4GB以上，硬盘空间100GB 以上。
3·2 软件环境：操作系统（Windows 10），编译器（C++编译器）。
4·实验步骤4·1 初始化栈：创建一个空栈，初始化栈顶指针。
4·2 进栈操作：将元素依次压入栈中，每次将栈顶指针加1，并判断栈是否已满。
4·3 出栈操作：将栈顶元素弹出栈，每次将栈顶指针减1，并判断栈是否为空。
4·4 获取栈顶元素：获取栈顶元素的值，不改变栈的结构。
4·5 清空栈：将栈中的所有元素清空。
5·实验结果5·1 在进行进栈操作时，栈能够正确判断是否已满。
当栈已满时，无法继续进行进栈操作。
5·2 在进行出栈操作时，栈能够正确判断是否为空。
当栈为空时，无法继续进行出栈操作。
5·3 栈的功能和性能符合设计要求，能够正常进行进栈、出栈、获取栈顶元素和清空栈等操作。
6·实验应用顺序栈可以被广泛应用于各种场景，例如：6·1 括号匹配：利用顺序栈的先进后出特性，可以有效地判断表达式中的括号是否匹配。
6·2 图的深度优先搜索：在图的深度优先搜索算法中，可以利用顺序栈保存当前节点的邻接节点，以便进行遍历。
6·3 数制转换：可以利用顺序栈实现将十进制数转换为其他进制数的功能。
7·附件本文档无涉及附件内容。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
return 0;
} *s.top=e; s.top++; return OK; } Status Pop(SqStack &s,SElemType &e) //元素出栈 { if(s.top==s.base) return ERROR; e=*(--s.top); return OK; } Status GetTop(SqStack s,SElemType &e) //获取栈顶元素 { if(s.top==s.base)return ERROR; e=*(s.top-1); return OK; } int main() { SqStack s;SElemType e;int n; printf("请输入要进栈的元素个数：\n"); scanf("%d",&n); InitStack(s); printf("请输入%d 个数：\n",n); for(int i=1;i<=n;i++) { scanf("%d",&e); Push(s,e); } printf("-----------------------------------\n"); printf("接下来的操作是删除栈顶元素：\n"); Pop(s,e); printf("删除的栈顶元素为：%d\n",e); printf("-----------------------------------\n"); printf("接下来的操作是插入一个元素，请输入要插入的元素：\n"); scanf("%d",&e); Push(s,e); GetTop(s,e); printf("插入元素后再获取第一个元素，获得的元素为：%d\n",e); printf("-----------------------------------\n"); if(ClearStack(s)) printf("清除栈成功。\n"); else printf("清除栈失败！\n"); printf("-----------------------------------\n"); if(DestroyStack(s)) printf("销毁栈成功。\n"); else return 0; } 实验第二题： 1. 先想好整个程序的思路。首先，定义两种栈分别用来存储运算符和数字。栈的基本函数都 要有。输入时输入字符串。对字符串进行判断是否输入正确。如果正确，则对字符串进行处 理。写一个能将字符串转化成数字的函数，用来提取字符串中的函数。此时定义一个结构体 数组， 结构体数组里包含共用体， 把字符串的数字和运算符全部区分存入结构体数组的共用 体。即： printf("销毁栈失败！\n");
int stacksize; }SqStack_op; Status InitStack_num(SqStack_num &s) {//初始化操作数栈 s.base=(SElemType_num *)malloc(STACK_INIT_SIZE*sizeof(SElemType_num)); if(!s.base)exit(OVERFLOW); s.top=s.base; s.stacksize=STACK_INIT_SIZE; return OK; } Status InitStack_op(SqStack_op &s) {//初始化操作码栈 s.base=(SElemType_op *)malloc(STACK_INIT_SIZE*sizeof(SElemType_op)); if(!s.base)exit(OVERFLOW); s.top=s.base; s.stacksize=STACK_INIT_SIZE; return OK; } Status push_num(SqStack_num &s,SElemType_num e) {//将操作数压入数字栈 if(s.top-s.base>=s.stacksize) { s.base=(SElemType_num *)realloc(s.base,(s.stacksize+STACKINCREMENT)*sizeof (SElemType_num)); if(!s.base)exit(OVERFLOW); s.top=s.base+s.stacksize; s.stacksize+=STACKINCREMENT; } *s.top=e; s.top++; return OK; } Status push_op(SqStack_op &s,SElemType_op e)
-3-
这里 cc 用来存储时数字还是运算符， 数字存 N，运算符存 O；如果是数字，保存到 uu[i].u.num，如果是运算符保存到 uu[i].u.opr ；然后 对结构体数组（包含共用体）一个一个进行判断；如果是数字则进数字栈，若是运算符则与 字符栈的栈顶元素进行比较，然后操作计算。这里就需要一个判断运算优先级的函数，和一 个操作运算的函数。 2. 写出各自对应的几大功能函数： Status InitStack_num(SqStack_num &s) //初始化操作数栈 Status InitStack_op(SqStack_op &s) //初始化操作码栈 Status push_num(SqStack_num &s,SElemType_num e) //将操作数压入数字栈 Status push_op(SqStack_op &s,SElemType_op e) //将操作码压入字符栈 Status pop_num(SqStack_num &s,SElemType_num &e) //弹出数字栈栈顶元素 Status pop_op(SqStack_op &s,SElemType_op &e) //弹出字符栈栈顶元素 Status GetTop_op(SqStack_op s,SElemType_op &e) //获取字符栈的栈顶 Status GetTop_num(SqStack_num s,SElemType_num &e) //获取数字栈的栈顶 int precede_op(SElemType_op a,SElemType_op b) //判断字符的优先级 SElemType_num calculate(SElemType_num x,SElemType_num y,SElemType_op cc) //这里注意 出栈顺序，在减法以及除法时要注意，第一个弹出的数应该是 y，第二个弹出的数应该是 x Status check(char str[]) //检查字符串是否合法 double exchange(char str[],int dot) //将字符串转化为小数 3. 完整代码如下： //data struct 实验三 stack 栈 _表达式求值 #include<stdio.h> #include<stdlib.h> #include<string.h> #define FALSE 0 #define TRUE 1 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -2 typedef double SElemType_num; typedef int SElemType_op; typedef int Status; char s[100]; #define STACK_INIT_SIZE 100 #define STACKINCREMENT 10 struct evaluation { char cc; union
实验报告 3
课程 数据结构 实验名称 顺序栈基本操作
专业 信息科学与技术类 年 9 班级__1___ 月 28 日 学号_ 姓名 评分 实验日期： 2010
第
页
一、实验目的
1．熟悉并能实现栈的定义和基本操作。 2．了解和掌握栈的应用。
二、实验要求
1．进行栈的基本操作时要注意栈"后进先出"的特性。 2．编写完整程序完成下面的实验内容并上机运行。 3．整理并上交实验报告。
-4-
{SElemType_num num; SElemType_op opr; }u; }uu[100]; typedef struct { SElemType_num *base; SElemType_num *top; int stacksize; }SqStack_num; typedef struct { SElemType_op *base; SElemType_op *top;
三、实验内容
1．编写程序任意输入栈长度和栈中的元素值，构造一个顺序栈，对其进行清空、销毁、 入栈、出栈以及取栈顶元素操作。 2．编写程序实现表达式求值，即验证某算术表达式的正确性，若正确，则计算该算术 表达式的值。 主要功能描述如下： （1）从键盘上输入表达式。 （2）（2）分析该表达式是否合法： a) 是数字，则判断该数字的合法性。若合法，则压入数据到堆栈中。 b) 是规定的运算符，则根据规则进行处理。在处理过程中，将计算该表达式的值。 c) 若是其它字符，则返回错误信息。 （3）若上述处理过程中没有发现错误，则认为该表达式合法，并打印处理结果。 程序中应主要包含下面几个功能函数： void initstack()：初始化堆栈 int Make_str()：语法检查并计算 int push_operate(int operate)：将操作码压入堆栈 int push_num(double num)：将操作数压入堆栈 int procede(int operate)：处理操作码 int change_opnd(int operate)：将字符型操作码转换成优先级 int push_opnd(int operate)：将操作码压入堆栈 int pop_opnd()：将操作码弹出堆栈 int caculate(int cur_opnd)：简单计算+，-，*，/ double pop_num()：弹出操作数