括号匹配(数据结构实验报告)

合集下载

括号匹配栈实验报告

括号匹配栈实验报告

一、实验目的本次实验旨在通过编写程序实现括号匹配功能,加深对栈数据结构原理的理解和应用。

通过实验,掌握栈的基本操作,如入栈、出栈、判断栈空等,并学会利用栈解决括号匹配问题。

二、实验原理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)的数据结构,本实验要求利用栈实现简单的括号匹配和后缀表达式计算。

通过实验,我了解到栈可以方便地实现对于括号的匹配和后缀表达式的计算,有效地解决了对应的问题。

实验三:队列的应用队列是一种先进先出(FIFO)的数据结构,本实验要求利用队列实现银行排队和迷宫求解。

通过实验,我对队列的应用有了更加深入的了解,了解到队列可以解决需要按顺序处理的问题,如排队和迷宫求解等。

实验四:链表的应用链表是一种常用的数据结构,本实验要求利用链表实现学生信息管理系统。

通过实验,我对链表的应用有了更深入的了解,了解到链表可以方便地实现对于数据的插入、删除和修改等操作,并且可以动态地调整链表的长度,适应不同的需求。

通过本次实验,我掌握了线性表、栈、队列和链表的基本操作,并了解了它们的特点和应用方式。

同时,通过实际编程的过程,我对于数据结构的实现方式和效果有了更直观的认识,也锻炼了自己的编程能力和解决问题的能力。

在实验过程中,我遇到了一些问题,如程序逻辑错误和内存泄漏等,但通过调试和修改,最终成功解决了这些问题,对自己的能力也有了更多的信心。

通过本次实验,我深刻体会到了理论与实践的结合的重要性,也对于数据结构这门课程有了更加深入的理解。

总之,本次数据结构实验给予了我很多有益的启发和收获,对于数据结构的概念、特点和应用有了更深入的理解。

在以后的学习中,我会继续加强对数据结构的学习和研究,不断提高自己的编程能力和解决问题的能力。

数据结构-栈的实现之括号匹配检测

数据结构-栈的实现之括号匹配检测

数据结构-栈的实现之括号匹配检测假设表达式中只允许两种括号:()、{};正确表达顺序为:()或{}或({})或{({}{})}的形势;如{(}或(})或({)}的表达形势均不对。

算法的设计思想: 出现左括弧则进栈; 出现右括弧则⾸先检测栈是否为空, 若栈空则表明此右括弧多余,表达式不匹配。

否则和栈顶数据⽐较,若匹配则栈顶出栈。

否则表明表达式不匹配; 最后若栈空且没有做鱼右括弧则匹配正确,否则表明不匹配。

实现代码如下(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 }测试只要输⼊表达式格式正确,则匹配结果是正确的。

数据结构实验报告

数据结构实验报告

数据结构实验报告一、实验目的本实验旨在通过对数据结构的学习和实践,掌握基本的数据结构概念、原理及其应用,培养学生的问题分析与解决能力,提升编程实践能力。

二、实验背景数据结构是计算机科学中的重要基础,它研究数据的存储方式和组织形式,以及数据之间的关系和操作方法。

在软件开发过程中,合理选用和使用数据结构,能够提高算法效率,优化内存利用,提升软件系统的性能和稳定性。

三、实验内容本次实验主要涉及以下几个方面的内容:1.线性表的基本操作:包括线性表的创建、插入、删除、查找、修改等操作。

通过编程实现不同线性表的操作,掌握它们的原理和实现方法。

2.栈和队列的应用:栈和队列是常用的数据结构,通过实现栈和队列的基本操作,学会如何解决实际问题。

例如,利用栈实现括号匹配,利用队列实现银行排队等。

3.递归和回溯算法:递归和回溯是解决很多求解问题的常用方法。

通过编程实现递归和回溯算法,理解它们的思想和应用场景。

4.树和二叉树的遍历:学习树和二叉树的遍历方法,包括前序、中序和后序遍历。

通过编程实现这些遍历算法,加深对树结构的理解。

5.图的基本算法:学习图的基本存储结构和算法,包括图的遍历、最短路径、最小生成树等。

通过编程实现这些算法,掌握图的基本操作和应用。

四、实验过程1.具体实验内容安排:根据实验要求,准备好所需的编程环境和工具。

根据实验要求逐步完成实验任务,注意记录并整理实验过程中遇到的问题和解决方法。

2.实验数据采集和处理:对于每个实验任务,根据要求采集并整理测试数据,进行相应的数据处理和分析。

记录实验过程中的数据和结果。

3.实验结果展示和分析:将实验结果进行适当的展示,例如表格、图形等形式,分析实验结果的特点和规律。

4.实验总结与反思:总结实验过程和结果,回顾实验中的收获和不足,提出改进意见和建议。

五、实验结果与分析根据实验步骤和要求完成实验任务后,得到了相应的实验结果。

对于每个实验任务,根据实验结果进行适当的分析。

编写一个括号匹配的检验的程序实习报告

编写一个括号匹配的检验的程序实习报告

编写一个括号匹配的检验的程序实习报告在计算机科学领域,括号匹配是一个常见的问题。

括号匹配指的是在一个字符串中,所有的括号都必须正确地成对出现。

如果所有的括号都能正确地匹配,那么该字符串是合法的;否则,该字符串是非法的。

在本次程序实习中,我设计并实现了一个括号匹配的检验程序。

首先,我对括号匹配的问题进行了深入的研究和分析。

我发现,括号匹配问题可以通过使用栈来解决。

栈是一种遵循后进先出原则的数据结构,在括号匹配问题中非常适用。

我使用了一个栈来存储左括号,并在遍历字符串时进行匹配操作。

接下来,我实现了一个简单而高效的括号匹配检验程序。

该程序可以接收一个字符串作为输入,并判断该字符串中的括号是否匹配。

我使用了编程语言(例如C++或Python)来实现该程序,具体的实现细节如下:1. 首先,我创建了一个空栈,用来存储左括号。

2. 然后,我遍历输入的字符串,逐个检查每个字符。

3. 如果当前字符是左括号(例如'('、'{'或'['),则将其推入栈中。

4. 如果当前字符是右括号(例如')'、'}'或']'),则检查栈是否为空。

如果栈为空,则字符串中的右括号没有相应的左括号,该字符串是非法的;如果栈不为空,则将栈顶的左括号弹出并与当前的右括号进行匹配。

如果两个括号不匹配,那么该字符串是非法的。

5. 最后,当遍历完整个字符串后,检查栈是否为空。

如果栈为空,则说明所有的左括号都有相应的右括号,该字符串是合法的;如果栈不为空,则说明字符串中存在未匹配的左括号,该字符串是非法的。

通过实现这个括号匹配的检验程序,我学到了许多关于栈的知识和算法设计的技巧。

此外,我也加深了对括号匹配问题的理解和掌握。

通过编写和调试这个程序,我提高了自己的编程能力和解决问题的能力。

总的来说,本次括号匹配的检验程序实习让我深入了解了括号匹配问题,并通过实际动手编写代码来解决这个问题。

数据结构实验报告 模式匹配算法

数据结构实验报告 模式匹配算法

return 1; } datatype DeQueue(SeqQueue *q) { datatype x; if(q->front==q->rear) { printf("\nempty!");return 0;} x=q->data[q->front]; q->front=(q->front+1)%max; return x; } void display(SeqQueue *q) { int s; s=q->front; if(q->front==q->rear) printf("empty!"); else while(s!=q->rear) { printf("->%d",q->data[s]); s=(s+1)%max; } printf("\n"); } main() { int a[6]={3,7,4,12,31,15},i; SeqQueue *p; p=InitQueue(); for(i=0;i<6;i++) EnQueue(p,a[i]); printf("output the queue values:"); display(p); printf("\n"); EnQueue(p,100);EnQueue(p,200);
ห้องสมุดไป่ตู้
元素并显示结果为4 ,12, 31, 15 ,100 ,200。
七、具体程序 #include "stdio.h" #include "conio.h" #define max 100 typedef int datatype; typedef struct { datatype data[max]; int front; int rear; }SeqQueue; SeqQueue *InitQueue() { SeqQueue *q; q=(SeqQueue *)malloc(sizeof(SeqQueue)); q->front=q->rear=0; return q; } int QueueEmpty(SeqQueue *q) { if (q->front==q->rear) return 1; else return 0; } int EnQueue(SeqQueue *q,datatype x) { if((q->rear+1)%max==q->front) {printf("\nfull!");return 0;} q->data[q->rear]=x; q->rear=(q->rear+1)%max;

数据结构实验报告

数据结构实验报告

数据结构实验报告1000实验一顺序表的删除Description实现一个线性表,对一个n不超过1000的线性表进行删除操作。

Input第一行有一个整数n,表示线性表的大小,第二行有n个整数,分别是list1,list2...listn。

第三行有一个整数q,表示q次删除操作,接下来q 行,每行有一个整数k,表示删除线性表中第k个元素。

(输入有多组测试数据,以EOF结束)Output对于每次删除操作输出一行,如果k不合法(k大于n或者k为0),输出-1, 否则输出删除的元素。

Sample Input5 3 2 1 5 4 3 5 5 2Sample Output4 -1 2#include <stdio.h>void sq_delete(int list[],int n,int j,int k[]){int i,t;for(i=0;i<j;i++){if(k[i]>n||k[i]<=0)printf("-1\n");else{printf("%d\n",list[k[i]-1]);for(t=k[i];t<n;t++)list[t-1]=list[t];n--;}}}int main(){int z,n,list[1024],j,k[1024];scanf("%d",&n);for(z=0;z<n;z++)scanf("%d",&list[z]);scanf("%d",&j);for(z=0;z<j;z++) scanf("%d",&k[z]);sq_delete(list,n,j,k);}运行结果:1001实验二链表及其多项式相加Description通过有序对输入多项式的各个项,利用单链表存储该一元多项式,并建立的2个存储一元多项式的单链表,然后完成2个一元多项式的相加,并输出相加后的多项式。

数据结构栈和队列实验报告

数据结构栈和队列实验报告

数据结构栈和队列实验报告一、实验目的本次实验的主要目的是深入理解和掌握数据结构中的栈和队列的基本概念、操作原理以及实际应用。

通过编程实现栈和队列的相关操作,加深对其特性的认识,并能够运用栈和队列解决实际问题。

二、实验环境本次实验使用的编程语言为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)的操作。

C语言实验二、括号匹配

C语言实验二、括号匹配

实验二、括号匹配一、问题描述假设一个输入字符串中包含圆括号、方括号和花括号三种类型的括号,以及其它一些任意字符。

编写程序,判别串中的括号是否正确匹配,即必须满足以下条件1.各种左、右括号的个数要一致;2.要符合正确的嵌套规则。

基本方法:在算法中设置一个栈,每读入一个括号,若是右括号,则或者使置于栈顶的最后进入的左括号消解,或者是不合法的情况;若是左括号,则压入栈中,同时在算法的开始和结束时,栈都应该为空,否则不合法。

二、基本要求输入一个算术表达式,利用栈存储结构来存入左括号,然后判断表达式中的括号是否匹配。

三、测试数据(1)([3+2]+(7*9))(2)[([3/2 ]-[5*6])](3)[7+8-(8-9])(4)(2+](3*9)))四、实现提示1、算法思路(1)对于栈的操作包括初始化initstack、判断栈是否满sfull、判断栈是否空sempty、入栈push和出栈pop操作。

该函数被主函数调用。

(2)在主函数中输入一个算术表达式,依次取出该算术表达式的某个字符,如果是左括号则入栈,如果是右括号则出栈,并判断右括号与出栈的元素是否匹配。

当算术表达式取完后,再判断栈是否为空,如果不空,则说明括号不匹配。

2、数据结构typedef struct stk//定义的栈结构{char *s; //栈中存放元素int top;//栈顶指针}stack;3、基本操作void initstack(stack *st) /* 栈s1和s2的初始化操作,st为指向s1或s2的指针 */int sfull(stack st) /* 判断栈s1和s2是否满的操作 */int sempty(stack st) /* 判断栈s1和s2是否空的操作 */int push(stack st,char e) /* 入栈操作,e为栈中结点类型 */int pop(stack *st,char *e) /*出栈操作,e为指向栈中结点的指针类型 */5、主程序main(){int i=0;char e;stack s1;//存放左括号的栈char str[100];//存放算术表达式的值initstack(&s1);printf("请输入表达式\n");gets(str);//输入算术表达式while(i<strlen(str)){if (str[i]=='('||str[i]=='['||str[i]=='{'){……}else if (str[i]==')'||str[i]==']'||str[i]=='}'){……else i++;}……}5、输出结果测试数据(1)([3+2]+(7*9))括号匹配(2)[([3/2 ]-[5*6])]括号匹配(3)[7+8-(8-9])第10个元素左右括号不匹配(4)(2+](3*9)))第4个元素左右括号不匹配。

简易计算器实验报告

简易计算器实验报告

简易计算器实验报告一、实验目的本次实验的目的是设计并实现一个简易计算器,能够进行基本的四则运算(加、减、乘、除),以及处理括号的优先级运算,提高对程序设计和逻辑思维的理解与应用能力。

二、实验原理1、四则运算的优先级规则在数学运算中,先计算括号内的表达式,然后按照先乘除后加减的顺序进行计算。

乘除法的优先级高于加减法,如果在同一级运算中,按照从左到右的顺序进行。

2、数据结构的选择使用栈(Stack)数据结构来存储操作数和运算符。

栈具有先进后出的特点,非常适合处理表达式中的括号和优先级。

3、算法思路首先,将输入的表达式进行解析,将数字和运算符分别存储到不同的栈中。

然后,根据运算符的优先级进行计算,将计算结果重新压入栈中,直到表达式计算完毕。

三、实验设备及环境1、编程工具:选择了 Python 语言作为主要的编程工具,使用PyCharm 集成开发环境进行代码编写和调试。

2、操作系统:Windows 10 操作系统。

四、实验步骤1、定义数据结构定义两个栈,一个用于存储操作数(operandStack),一个用于存储运算符(operatorStack)。

2、表达式解析遍历输入的表达式字符串,将数字转换为整数并压入操作数栈,将运算符压入运算符栈。

遇到左括号直接压入运算符栈,遇到右括号则进行括号内的运算。

3、运算处理当运算符栈不为空时,取出栈顶的运算符和两个操作数进行计算。

根据运算符的优先级进行相应的运算,将结果压入操作数栈。

4、最终结果当表达式解析完毕后,操作数栈中的唯一元素即为表达式的计算结果。

五、代码实现```pythonclass SimpleCalculator:def __init__(self):selfoperandStack =selfoperatorStack =def calculate(self, expression):for char in expression:if charisdigit():selfoperandStackappend(int(char))elif char in '+/()':if char =='(':selfoperatorStackappend(char)elif char ==')':while selfoperatorStack-1!='(':operator = selfoperatorStackpop()operand2 = selfoperandStackpop()operand1 = selfoperandStackpop()result = selfperformOperation(operand1, operand2, operator)selfoperandStackappend(result)selfoperatorStackpop()else:while selfoperatorStack and selfhasHigherPrecedence(selfoperatorStack-1, char):operator = selfoperatorStackpop()operand2 = selfoperandStackpop()operand1 = selfoperandStackpop()result = selfperformOperation(operand1, operand2, operator)selfoperandStackappend(result)selfoperatorStackappend(char)while selfoperatorStack:operator = selfoperatorStackpop()operand2 = selfoperandStackpop()operand1 = selfoperandStackpop()result = selfperformOperation(operand1, operand2, operator)selfoperandStackappend(result)return selfoperandStackpop()def hasHigherPrecedence(self, op1, op2):if op1 in '/' and op2 in '+':return Trueelif op1 in '+' and op2 in '+':return Falseelif op1 in '/' and op2 in '/':return Falsereturn Falsedef performOperation(self, operand1, operand2, operator):if operator =='+':return operand1 + operand2elif operator =='':return operand1 operand2elif operator =='':return operand1 operand2elif operator =='/':if operand2 == 0:raise ValueError("除数不能为 0")return operand1 / operand2if __name__ =="__main__":calculator = SimpleCalculator()expression ="2 + 3 (4 1) / 2"result = calculatorcalculate(expression)print("计算结果:", result)```六、实验结果与分析1、测试用例及结果输入表达式:"2 + 3 4",计算结果:14输入表达式:"(2 + 3) 4",计算结果:20输入表达式:"5 2 3",计算结果:-1输入表达式:"10 / 2 + 1",计算结果:62、结果分析对于简单的四则运算表达式,计算器能够正确计算出结果。

数据结构括号匹配实验报告

数据结构括号匹配实验报告

括号的匹配1. 需求和规格说明(1)实现括号的是否匹配的判定。

(2)实现匹配错误的提示。

(3)实现栈内容的动态显示。

2.设计2.1.设计思想(1)对于括号匹配的判定,首先输入字符串到缓冲区。

逐个字符读取字串,遇到的是左括号则入栈,若是右括号,则出栈。

出栈的左括号如果和右括号匹配,则一对括号匹配成功;否则,这对括号匹配失败,并给出错误提示。

(2)分析括号匹配错误出现的情况,主要有三种:左括号数大于右括号数,左括号与右括号不匹配,右括号数大于左括号数。

根据栈的存储情况就能判定出这三种情况,并且实时的将信息放映到可视化控件上。

(3)对于匹配过程和栈内容的动态显示,可以用listbox 控件实时的显示和更新。

窗口上有两个listbox 控件,第一个动态显示push 和pop 动作以及提示错误信息;第二个listbox 则动态模拟栈内的存储情况。

2.2.设计表示(1)存储结构Node 节点template <class element>class 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<element> *temp=new Node(e); return temp;}};MyListStack 链栈template <class element> class MyListStack{public:Node<element> *base;Node<element> *top;int index;MyListStack() //初始化链表{base=new Node<element>(); top=base;index=0;}void push(element n) //push{Node<element> *temp=new Node<element>(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;else return TRUE;}virtual ~MyListStack() //析构链栈,释放空间{Node<element> *p=base; Node<element> *q=p->next;while(p->next!=NULL){ delete p; p=q; q=p->next;} delete p;}};(2)涉及的操作void CKuohaopipeiDlg::OnButtonClear() // 清空窗口控件。

括号匹配检测实验报告

括号匹配检测实验报告

括号匹配检测实验报告本实验旨在设计和实现一个括号匹配检测算法,检测给定字符串中的括号是否正确匹配。

实验原理:括号匹配检测是一种常见的算法问题。

其基本原理是利用栈(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, "匹配失败")实验结果:运行测试用例,可以得到以下结果:- "()" 匹配成功- "{[]}" 匹配成功- "[{()}]" 匹配成功- "(}" 匹配失败- "{[}]" 匹配失败实验讨论:根据实验结果,我们可以看到算法能够正确地检测出括号的匹配情况。

(数据结构)括号匹配的检验(源代码)

(数据结构)括号匹配的检验(源代码)

数据结构括号匹配问题#include<stdio.h>#include<stdlib.h>#define TURE 1#define FALSE 0#define OK 1#define ERROR 0#define INEEASLIBE -1#define OVERFLOW -2typedef int status;typedef char elemtype;typedef struct{elemtype *data;int length;elemtype *top;}list;status creat(list &L){L.data=(elemtype*)malloc(2*sizeof(elemtype));if(!L.data){return ERROR;}L.top=L.data;L.length=1;return OK;}status push(list &L,elemtype e){elemtype *dat;dat=(elemtype*)realloc(L.data,(L.length+1)*sizeof(elemtype));if(!dat){return ERROR;}L.data=dat;L.length++;*(L.top)=e;L.top++;return OK;}status pop(list &L,elemtype &e){if(L.top==L.data){printf("\n已是堆低无数据元素\n");return ERROR;}L.top--;e=*(L.top);return OK;}main(){list L;creat(L);char a[20],b;int i=0,m=0;while(i<20){printf("请输入括号序列:('#'表示输入结束)\n");scanf("%c",&a[i]);getchar();if(a[i]=='#'){break;}if(a[i]=='('||a[i]==')'||a[i]=='['||a[i]==']'||a[i]=='{'||a[i]=='}'||a[i]== '<'||a[i]=='>'){i++;}else{printf("输入的不是括号字符\n请重新输入\n");}}m=i;i=0;while(i<m){if(a[i]==']'||a[i]==')'||a[i]=='}'){if(L.top==L.data){printf("括号匹配出错\n");exit(0);}else{pop(L,b);if((a[i]-b)!=2&&(a[i]-b)!=1){printf("括号匹配出错\n");exit(0);}}}elsepush(L,a[i]);i++;}if(L.data!=L.top)printf("括号匹配出错\n");elseprintf("\n\n括号匹配成功\n");}THANKS !!!致力为企业和个人提供合同协议,策划案计划书,学习课件等等打造全网一站式需求欢迎您的下载,资料仅供参考。

括号匹配实验报告

括号匹配实验报告

括号匹配实验报告实验报告课程名称:数据结构班级:实验成绩:实验名称:栈、队列、字符串和数组学号:批阅教师签字:实验编号:实验⼆姓名:实验⽇期:指导教师:组号:实验时间:⼀、实验⽬的(1)掌握栈、队列、串和数组的抽象数据类型的特征。

(2)掌握栈、队列、串和数组的抽象数据类型在计算机中的实现⽅法。

(3)学会使⽤栈、队列来解决⼀些实际的应⽤问题。

⼆、实验内容与实验步骤(1)实验内容:假设表达式中除了变量名、常量和运算符外,还可以允许两种括号:圆括号和中括号,其嵌套的次序随意,编写程序检验输⼊的表达式中括号的的顺序是否合法。

(2)描述抽象数据类型或设计的函数描述,说明为什么要使⽤这种抽象数据类型,并说明解决设想。

抽象数据类型或函数描述:⾸先定义了⼀个结构体并且声明为栈类型,在其中定义了空间基地址的指针、栈顶指针以及栈存储空间的⼤⼩。

之后设计了Creat _Stack的函数,⽤此函数来创建⼀个空栈,这样可以使⽤堆栈来实现括号匹配的功能,⼜设计了⼀个名为Stack_Full的函数了来判断栈是否已满,若栈未满才可继续之后的压栈功能,如果堆栈已满,则需要使⽤realloc来动态分配空间,扩⼤栈的存储空间。

我还设计了⼀个名为empty的函数,⽤它来判断堆栈是否为空,堆栈为空或不为空时分别返回0或1。

之后设计了名为push和pop的函数来实现括号的⼊栈和出栈,之后设计了名为Match的函数,来判断括号是否匹配,设计了名为clean的函数来清空堆栈,这样可以连续判断不同的多项式的括号是否匹配。

解决设想:对于本题,⾸先我使⽤了栈结构,利⽤栈中数据“先进后出”的特点来实现对括号是否匹配的检验。

实现过程基本如下:从左到右依次扫描多项式,如果遇到左括号便将左括号⼊栈,在所有左括号⼊栈之后便可以扫描到右括号,如果扫描到的右括号和栈顶的左括号可以匹配时,将左括号出栈,以此类推,最后判断栈是否为空,若为空,则括号匹配,否则括号不匹配。

括号匹配检测实验报告(3篇)

括号匹配检测实验报告(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)}")```四、实验结果与分析通过上述代码,我们对一系列测试用例进行了括号匹配检测。

括号匹配问题

括号匹配问题

东华理工大学长江学院课程设计报告数据结构课题设计报告设计题目:括号匹配问题姓名:班级:学号:指导老师:二0一0年五月目录1.设计内容 (1)问题描述 (1)问题分析 (1)2.概要设计 (2)2-1模块一:初始化一个堆栈 (2)2-2模块二:进栈 (2)2-3模块三:测试堆栈是否为空 (2)2-4模块四:退栈 (2)2-5模块五:各模块间的调用关系 (2)3.算法描述 (3)3-1程序流程图: (3)3-2程序代码: (4)4.算法分析 (6)5.心得体会 (8)6.参考资料 (8)1.设计内容问题描述假设一个算术表达式中可包含三种括号:圆括号,方括号和花括号且这三种括号可按任意次序嵌套使用。

试利用栈的运算,编写判别给定表达式中所含括号是否正确配对出现的算法。

问题分析此程序须要完成如下要求:表达式中有三种括号:圆括号、方括号和花括号,嵌套顺序任意。

实现本程序需要解决:①用什么数据结构;②怎样实现判断括号是否匹配;③括号匹配与否有几种情况;④输出与输入数据的形式。

本程序的难点在于怎么判断括号是否匹配。

2.概要设计2-1模块一:初始化一个堆栈堆栈的顺序存储结构可以利用一个具有M个元素的数组STACK[0..M-1]来描述。

其中,STACK作为堆栈的名字,且不妨设:#define M 100 */定义堆栈的最大容量,并初始化栈顶指针变量top=-1。

2-2模块二:进栈在容量为M的堆栈中插入一个新的元素E[i],栈顶元素的位置由top指出。

新的数据元素进栈,将栈顶指针加1,然后将新的数据元素E[i]插入到修改以后的top指出的新的栈顶位置上。

2-3模块三:测试堆栈是否为空测试堆栈是的栈顶指针top是否为-1。

2-4模块四:退栈从堆栈中退出当前栈顶元素,并保存在变量item中,同时将栈顶指针减1修改栈顶指针位置。

2-5模块五:各模块间的调用关系首先创建一个堆栈并初始化,依次读入字符直到文件的末尾。

如果读得的字符为左括号,则将其压入堆栈。

数据结构实践报告文库版

数据结构实践报告文库版

数据结构实践报告文库版一、实践背景数据结构是计算机科学中的基础课程,通过学习和实践数据结构,可以增强学生对计算机系统底层原理的理解,培养学生的编程能力和问题解决能力。

本实践报告主要介绍了我在学习数据结构课程过程中的实践经验和学习成果。

二、实践内容本次实践主要包括以下几个方面:1.线性表:学习并实现了线性表的顺序存储结构和链式存储结构,并比较两种结构的优缺点。

通过实践,我深入理解了线性表的基本概念和操作,对于线性表的插入、删除和查找等操作也有了较为熟练的掌握。

2.栈与队列:学习并实现了栈和队列的基本操作,并通过实践中的应用场景,如括号匹配、迷宫求解等,加深了对栈和队列的理解。

通过实践,我发现栈和队列的应用非常广泛,对于问题的解决具有很强的实用性。

3.树与二叉树:学习并实现了树和二叉树的基本操作,如创建、遍历等,并通过实践中的应用场景,如表达式树、赫夫曼树等,进一步了解了树和二叉树的特点和应用。

通过实践,我发现树和二叉树在算法设计和数据处理中发挥着重要的作用,对于复杂问题的解决具有很大的帮助。

4.图:学习并实现了图的基本操作,如创建、遍历等,并通过实践中的应用场景,如最短路径问题、图的连通性等,加深了对图的理解。

通过实践,我认识到图是一种重要的数据结构,广泛应用于网络、社交等领域,对于解决复杂的关系问题具有重要作用。

三、实践成果通过对数据结构的学习和实践,我取得了如下成果:1.编程能力的提升:通过实践,我进一步熟悉了C/C++语言的基本语法和程序设计思想,提高了编程能力。

在实践过程中,我学会了如何分析问题、设计算法,并用代码实现,提高了自己的解决问题的能力。

2.问题解决能力的增强:通过实践过程,我掌握了一些常见问题的解决方法,如括号匹配、迷宫求解等。

在实践过程中,我学会了如何分析问题的特点和要求,选用合适的数据结构和算法进行解决,提高了解决问题的效率和质量。

3.学习能力的提高:通过实践,我更加深入地理解了数据结构的基本概念、操作和应用。

表达式括号匹配配对判断 大二数据结构实验

表达式括号匹配配对判断 大二数据结构实验

实验表达式括号匹配配对判断问题1,问题的描述假设一个算法表达式中包括圆括号,方括号两种,设计判别表达式中括号是否正确匹配的算法。

2,数据结构设计(1)匹配判别发生在右括号出现时,且被匹配的左括号应是距离右括号最近被输入的,二不是最先被输入的括号,即“先入后匹配”。

因此用栈来解决。

struct Node{int top;char data[stacksize];};Node node;void InitStack( ) // 初始化栈{node.top=-1;}(2)一是表达式的串;二是栈。

串可以采用顺序表表示。

所以采用顺序栈,站元素类型为字符型。

sqstack(int n){ base=newT[m];if(base=NULL){cout<<“创栈失败”;exit(1);}stacksize=m;top=-1;}}3,算法设计(1)进栈的算法设计voidPush(charx){if(node.top==stacksize-1);node.top++;node.data[node.top]=x;}(2)出栈的算法设计void Pop(char &x){if(node.top==-1);x=node.data[node.top--];}(3)判断是否匹配的算发。

如果右括号,进栈,取下个字符;如果是左括号,出栈,取下个字符;最后判断栈是否为空;得出结论。

3.1因为其中包含几种括号,所以用采用switch语句for(i=0;*(p+i)!='\0'&&count!=0;i++){switch (*(p+i)){case '(' :Push(*(p+i)) ;break ;case '[' :Push(*(p+i) ) ;break ;case ')' :{Pop(e) ;if ( e!='(' )count=0 ;};break ;case ']' :{Pop(e) ;if ( e!='[' )count=0 ;}; break ;default:break;}}3.2利用进出栈判断括号是否匹配if ( !StackEmpty () || count==0 ) //条件为:栈不空,而且有出现括号不匹配的情况{cout<<"括号无法匹配!"<<endl;cout<<"你想要继续吗?(y/n)"<<endl;cin>>s;if(s=='y'||s=='Y')goto input;else if(s=='n'||s=='N')cout<<"退出程序!"<<endl;return 0;}else{cout<<"括号能够匹配!"<<endl;cout<<"你想要继续吗?(y/n)"<<endl;cin>>s;if(s=='y'||s=='Y')goto input;else if(s=='n'||s=='N')cout<<"退出程序!"<<endl;return 0;}4.测试与运行(1)显示菜单,如下图:(2)运行结果如下图:5.调试的收获通过这次实验好的感觉到自己还有不足之处,一个程序高那么久才搞定,以后要多加练习。

数据结构-括号排序

数据结构-括号排序

.
8
A×[ (B-C) + (D-E) ] / (F + G)
2
1
pos = 0
0
(
pos = 1
.
9
A×[ (B-C) + (D-E) ] / (F + G)
3
2
pos = 0 1
(
pos = 1
.
10
总结
• 括号匹配处理中,将左括号依次存入数组, 每次存进去的左括号都是在数组的最上部, 一旦遇到左右括号匹配,将数组最上部的 左括号移走;
计算表达式括号匹配问题
假定表达式中只包含两种括号[ ]、(), 例如表达式:A×[ (B-C) + (D-E) ] / (F + G)
.
1
A×[ (B-C) + (D-E) ] / (F + G)
2 1 0
pos = 1
解题思路:
借助于数组顺序处理表达式 中的每个括号,遇到左括号依 次存入数组,遇到右括号,则 与数组最上部的左括号匹配, 如果发现括号匹配错误,则终 止检测过程。如果匹配成功, 则将顶部的左括号移走。继续 往下…,一直到最后一个括号
.
2
A×[ (B-C) + (D-E) ] / (F + G)
2
2
1
1
0
pos =
0
0
[
pos = 1
.
3
A×[ (B-C) + (D-E) ] / (F + G)
2
pos = 1
1
(
pos = 0
0
[
.
4
A×[ (B-C) + (D-E) ] / (F + G)

数据结构3.2.2链栈完成括号的匹配[精彩]

数据结构3.2.2链栈完成括号的匹配[精彩]

3.2.2链栈实现括号匹配/***链栈实现括号匹配***/#include<iostream>using namespace std;#define OK 1#define ERROR 0#define OVERFLOW -2typedef char SElemType;typedef int Status;typedef struct SNode{int data;struct SNode *next;}SNode,*LinkStack;Status InitStack(LinkStack &S){S = NULL;return OK;}bool StackEmpty(LinkStack S){if(!S)return true;return false;}Status Push(LinkStack &S,SElemType e) {SNode *p = new SNode;if(!p){return OVERFLOW;}p->data = e;p->next = S;S = p;return OK;}Status Pop(LinkStack &S,SElemType &e) {SNode *p;if(!S)return ERROR;e = S->data;p = S;S = S->next;delete p;return OK;}Status GetTop(LinkStack &S,SElemType &e){if(!S)return ERROR;e = S->data;return OK;}//算法3.9括号的匹配Status Matching(LinkStack S){//检验表达式中所含括号是否正确匹配,如果匹配,则返回true,否则返回false。

//表达式以“#”结束int flag=1; //标记查找结果以控制循环及返回结果char c;SElemType x;cin>>c; //读入第一个字符while(c!='#' &&flag){switch (c){case '[':case '(': //若是左括号,则将其压入栈Push(S,c);break;case ')' : //若是右括号“)”,则根据当前栈顶元素的值分情况考虑GetTop(S,x);if (!StackEmpty(S) && x=='(' )//若栈非空且栈顶元素是“(”,则匹配成功Pop(S,x);elseflag=0; //若栈空或栈顶元素不是“(”,则非法break;case ']' : //若是右括号“]”,则根据当前栈顶元素的值分情况考虑GetTop(S,x);if (!StackEmpty(S) && x=='[' ) //若栈顶元素是“[”,则匹配成功Pop(S,x);elseflag=0; //若栈空或栈顶元素不是“[”,则非法break;}//switchcin>>c; //继续读入下一个字符}//whileif (StackEmpty(S) &&flag )return 1;elsereturn 0;}//Matchingint main(){LinkStack S;InitStack(S);cout<<"请输入待匹配的表达式,以#结束:"<<endl;int flag = (int)Matching(S);if(flag)cout<<"括号匹配成功!"<<endl;elsecout<<"括号匹配失败!"<<endl;return 0;。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

课程名称: 《数据结构》课程设计课程设计题目: 括号匹配姓名:***院系:计算机科学与技术学院专业:计算机科学与技术年级:**学号:*******指导教师:***2015 年 09月 10 日目录1 课程设计的目的 (1)2 需求分析 (3)3 课程设计报告内容 (3)3.1概要设计 (3)3.2详细设计 (3)3.3调试分析 (5)4 总结 (7)5 程序清单 (8)6 参考文献 (7)1.课程设计的目的(1) 熟练使用C 语言编写程序,解决实际问题;(2) 了解并掌握数据结构与算法的设计方法,具备初步的独立分析和设计能力;(3) 初步掌握软件开发过程的问题分析、系统设计、程序编码、测试等基本方法和技能;(4) 提高综合运用所学的理论知识和方法独立分析和解决问题的能力;2.需求分析本程序文件主要的功能是判断括号的匹配问题。

程序的执行是从事先输入好数据的文档中读取,然后对所读取的数据进行括号匹配行的判断。

最后输出判断的结果。

程序函数主要有void InitStack(Stack *S)、ElemType GetTop(Stack S,ElemType *e)、void push(Stack *S,ElemType e)、ElemType pop(Stack *S,ElemType *e)、int Judge(ElemType a[])。

InitStack函数是用来初始化栈;GetTop函数是用来获取栈顶元素;push是用来把元素压栈、pop函数是用来把元素弹出栈、Judge函数是用来判断括号是否匹配。

3 括号匹配的设计3.1概要设计算法分析:首先设置好一个栈,然后从文件中读入数据,在读入的数据时,从文件中读取的字符串存入到函数定义好的字符数组中。

然后把该数组作为函数参数。

当每读入一个‘(’或者是‘[’,就把这个元素压栈,若是读入的元素是‘]’或者是‘)’,就调用GetTop函数,来获取栈顶元素,如果获取的栈顶元素和该次读入的元素匹配而且栈不空的话,就说明该元素是匹配的,继续比较下一次的元素;如果获取的栈顶元素和该次读入的元素不匹配的话,就说明该元素是不匹配的,直接结束运行。

当所有的‘)’或者是‘]’全部比较完成之后,栈仍然不空,说明栈中还剩有‘[’或者‘(’,括号不匹配。

3.2详细设计void InitStack(Stack *S)//建造一个栈{S->base = (ElemType *)malloc(STACK_INIT_SIZE *sizeof(ElemType));if(!*S->base) printf("error");S ->top = S ->base;//将栈设置为空栈S->stacksize = STACK_INIT_SIZE;//将栈的空间大小设置为STACK_INIT_SIZE}建栈的操作首先将栈指针s->指向新开辟的内存空间。

然后将栈顶指针s->top等于s->base。

将栈置成空栈。

ElemType GetTop(Stack S,ElemType *e)//获取栈顶元素{if(S.top!=S.base){*e=*(S.top-1);return *e;}该模块用于获取栈顶元素。

void push(Stack *S,ElemType e)//压栈函数{if(S->top-S->base>=S->stacksize){S->base=(ElemType*)realloc(S->base,(S->stacksize+STACKINCREMENT)*sizeof(ElemType));if(!S->base) printf("分配内存失败\n");else{S->top=S->base+S->stacksize;S->stacksize+=STACKINCREMENT;}}*S->top=e;S->top++;}该模块用于将元素压栈。

首先判断现有栈的空间是否够用,如果不够,就再分配内存。

然后将元素e赋值给栈顶指针所指位置。

最后将栈顶指针加一。

ElemType pop(Stack *S,ElemType *e)//出栈函数{if(S->top==S->base) printf("错误\n");else{*e=*--S->top;return *e;}}该模块用于将栈顶元素出栈。

int Judge(ElemType a[])//判断函数{int i=0;Stack s;InitStack(&s);ElemType x;while(a[i]){switch(a[i]){case '(':push(&s,a[i]);break;case '[':push(&s,a[i]);break;case ')':GetTop(s,&x);if(x=='('&&s.top!=s.base)pop(&s,&x);else {printf("不匹配\n");return 0;}break;case ']':GetTop(s,&x);if(x=='['&&s.top!=s.base)pop(&s,&x);else {printf("不匹配\n");return 0;}break;default:break;}i++;}if(s.top!=s.base) printf("不匹配\n");else printf("括号匹配\n");return 0;}该模块用于判断括号是否匹配。

3.3调试分析运行截图问题说明:当所判断的表达式中的‘]’‘)’元素比‘[’‘(’多时,例如:[[]])]]];这种情况下括号是不匹配的,但是程序运行就会发生错误,输出的判断结果仍然是括号匹配。

算法漏洞:存在漏洞的部分如图所示:解决方法:出现这种问题是因为当当所判断的表达式中的‘]’‘)’元素比‘[’‘(’多时,这时候就会当‘]’‘)’元素还没读取完时,就因为前面不断的出栈操作而把栈变成了空栈,这时候最后的判断条件就会因为这时候是空栈,s.top==s.base,所以就错误的判断成了括号是匹配的。

修改方案:只需在读取‘]’‘)’元素,在多加一个判断这是栈是否已经成为空栈的条件,就能把改问题解决了。

修改后如下图:3.4用户手册(略)3.5测试结果(略)4总结程序设计过程中有很多自己事先想不到的情况,这就会导致程序出现漏洞。

本次程序设计过程中就是因为在别人的输入条件下,程序出现了错误的输出结果,所以我才发现程序存在漏洞。

经过这次经验,我更加体会到了程序设计时情况考虑的周全性,要尽可能的考虑到较多的情况,在自己考虑好之后,在交由他人进行数据测试,这样才能尽可能的避免意料之外的情况。

5、程序清单:(见附录)6、参考文献1 严蔚敏,吴伟民编著. 数据结构(C 语言版)--北京: 清华大学出版社,2007.2严蔚敏,吴伟民米宁编著. 数据结构题集(C 语言版)--北京: 清华大学出版社,2007.3网上搜索相关程序作为参考7、程序运行结果运行截图附录(全部代码):#include<stdio.h>#include<stdlib.h>#include<malloc.h>#define ElemType char#define STACK_INIT_SIZE 100#define STACKINCREMENT 100 #define size 40typedef struct{ElemType *base;ElemType *top;int stacksize;}Stack;void InitStack(Stack *S)//建造一个栈{S->base = (ElemType *)malloc(STACK_INIT_SIZE *sizeof(ElemType));if(!*S->base) printf("error");S ->top = S ->base;//将栈设置为空栈S->stacksize = STACK_INIT_SIZE;//将栈的空间大小设置为STACK_INIT_SIZE}ElemType GetTop(Stack S,ElemType *e)//获取栈顶元素{if(S.top!=S.base){*e=*(S.top-1);return *e;}}void push(Stack *S,ElemType e)//压栈函数{if(S->top-S->base>=S->stacksize){S->base=(ElemType*)realloc(S->base,(S->stacksize+STACKINCREMENT)*sizeof(ElemType));if(!S->base) printf("分配内存失败\n");else{S->top=S->base+S->stacksize;S->stacksize+=STACKINCREMENT;}}*S->top=e;S->top++;}ElemType pop(Stack *S,ElemType *e)//出栈函数{if(S->top==S->base) printf("错误\n");else{*e=*--S->top;return *e;}}int Judge(ElemType a[])//判断函数{int i=0;Stack s;InitStack(&s);ElemType x;while(a[i]){switch(a[i]){case '(':push(&s,a[i]);break;case '[':push(&s,a[i]);break;case ')':GetTop(s,&x);if(x=='('&&s.top!=s.base)pop(&s,&x);else {printf("不匹配\n");return 0;}break;case ']':GetTop(s,&x);if(x=='['&&s.top!=s.base)pop(&s,&x);else {printf("不匹配\n");return 0;}break;default:break;}i++;}if(s.top!=s.base) printf("不匹配\n");else printf("括号匹配\n");return 0;}int main(){FILE *fp;char *a,*p; //定义字符指针a,用来存放从文件中读取的字符串int no;printf("请输入选择的文件:\n");printf(" 1.括号匹配的文件\n");printf(" 2.括号匹配的文件\n");printf(" 3.直接退出程序\n");printf("*******************************\n");scanf("%d",&no);switch(no){case 1:if ((fp=fopen("one.txt","r"))==NULL){printf("open file error!\n");return 0;}break;case 2:if ((fp=fopen("two.txt","r"))==NULL){printf("open file error!\n");return 0;}break;case 3:return 0;}a=(char*)malloc(30*sizeof(char));while(1){p=fgets(a,30,fp); //从文件指针fp所指向的文件中读取字符串存放到数组a中if(!p) break; //如果读取完毕,就跳出循环printf ("%s",a);Judge(a);//printf ("********************\n");}return 0; }。

相关文档
最新文档