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

括号匹配实验报告书

1．实验题目括号匹配的检验；2．需求分析本演示程序用VC++6.0编写，完成圆括号、方括号和大括号，其嵌套的顺序随意，即（（）[ ]）或{（[ ] [ ]）}等为正确格式，[[ ）]或（（（）均为不正确的格式。

①输入形式：直接输入一串括号；②输出形式：直接输出输入的括号串是否匹配的结果；③程序所能达到的功能：可以多次输入括号串并判断其是否匹配；④测试数据：输入（[ ]（）），结果“匹配”输入 [（ [）]，结果“此串括号匹配不合法”3．概要设计1）为了实现上述程序功能，需要定义栈的抽象数据类型：class Stack{数据对象：kh={ai|ai∈count,i=0,1,2,…,n,n≥0}数据关系：基本操作：push(char b)操作结果：把一个数据压进栈pop()操作结果：把一个数据弹出栈pp(char c[])初始条件：栈已存在操作结果：将栈中的元素进行匹配jc()初始条件：栈已存在操作结果：检查栈是否为空若空，返回0；若不空，返回1.clear()操作结果：清空栈2）本程序包含7个函数：①主函数main()②栈的构造函数Stack()③压栈操作函数push(char b)④弹栈操作函数pop()⑤匹配元素函数pp(char c[])⑥检查栈操作函数jc()⑦清空栈操作函数clear()各函数间关系如下：4．详细设计#include<iostream>#include<string>using namespace std;const int maxstack=100;//-------------------------------------------------------------------class Stack{//栈类public:Stack(){count=-1;};//初始化计数conutvoid push(char b);//压栈char pop();//弹栈void pp(char c[]);//匹配括号int jc();//检查是否为空栈void clear(){count=-1;}private:int count;//计数char a[maxstack];//存储};void Stack::push(char b)//压栈函数{if(count>=maxstack);else{count++;a[count]=b;}}char Stack::pop()//弹栈函数{if(count<0);else{return a[count--];}return 0;}int Stack::jc()//检查函数{if(count<0)return 0;return 1;}void Stack::pp(char c[])//匹配函数{int i=0,s=1,t;t=strlen(c);//测试输入的字符串长度if(c[0]==')'||c[0]==']'||c[0]=='}'||t%2==1)//判断是否为奇个括号或第一个为左括号{cout<<"此串括号匹配不合法"<<"\n"<<endl;}else //判断{while(c[i]!='\0'){if(c[i]=='('||c[i]=='['||c[i]=='{'){push(c[i]);}else{if(c[i]==')'){if(pop()!='('){s=0;break;}}if(c[i]==']'){if(pop()!='['){s=0;break;}}if(c[i]=='}'){if(pop()!='{'){s=0;break;}}}i++;}if(s==1){ if(!jc())cout<<"匹配"<<"\n"<<endl;else cout<<"此串括号匹配不合法"<<"\n"<<endl;}if(s==0)cout<<"此串括号匹配不合法"<<"\n"<<endl;}}//-------------------------------------------------------------------int main(){char a[maxstack];//数组Stack kh;//栈对象char h;cout<<"**************************"<<endl;cout<<"*** 括号匹配测试程序 ***"<<endl;cout<<"**************************"<<endl<<endl;do{cout<<"请输入您的选择: 1.运行程序; 2.结束。

数据结构中关于括号匹配问题的算法

《数据结构》实验报告二实验内容：括号匹配学号：姓名：一、上机实验的问题和要求（需求分析）：[ 题目] 假设表达式中允许有两种括号：圆括号和方括号，其嵌套的顺序随意，即（（）[ ]）或[（[ ] [ ]）] 等为正确格式，[（]）或（（（]均为不正确的格式。

读入含圆括号和方括号的符号序列，输出“匹配”或“此串括号匹配不合法”。

二、程序设计的基本思想，原理和算法描述：本程序是在实现栈的基本操作的基础上实现其基本应用，即括号匹配问题，重点利用其“先进后出”的特性三、调试和运行程序过程中产生的问题及采取的措施：（略）四、源程序及注释[ 源程序] 程序名： 4.cpp#include "stdio.h"#include "malloc.h"#include "process.h"#define stack_int_size 8#define stackincrement 10#define overflow -2#define error 0#define ok 1typedef int status;typedef char selemtype;typedef struct{ selemtype * base;selemtype * top;int stacksize;}sqstack;status initstack(sqstack &s){//构造一个空栈ss.base=(selemtype *)malloc(stack_int_size * sizeof(selemtype));if(!s.base)exit(overflow);s.top=s.base;s.stacksize=stack_int_size;return ok;}//initstackstatus emptystack(sqstack s){if(s.top==s.base)return ok;else return error;}status push(sqstack &s,selemtype e){//插入元素e为新的栈顶元素int stacksize;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){//若栈不为空，则删除s的栈顶元素，用e返回其值if(s.top==s.base)return error;e=* --s.top;return ok;}//popint kuohao(char m[]){ //若括号匹配则返回1，否则返回0；sqstack s;int i=0;char x;initstack(s);while(m[i]!='#'){ if(m[i]=='('||m[i]=='[')push(s,m[i]);if(m[i]==')'||m[i]==']'){ if(emptystack(s))return 0;else{pop(s,x);if((x=='('&&m[i]==']')||(x=='['&&m[i]==')'))return 0; } }i++;}if(emptystack(s))return 1;else return 0;}void main (){ char e[7]={'(','(','(',']',')',']','#'};int p;p=kuohao(e);printf("说明：若括号匹配的话，输出结果为1，反之则为0.\n");printf("判断结果为：%d\n",p); }五、运行结果如输入的括号序列为：'(','(','(',']',')',']','#'运行结果：0（表明括号不匹配）。

数据结构试验8括号匹配

问题描述：编写一程序判断从键盘输入的子符串括号是否匹配。

假设需判断的括号只有“（”，“）”，“[”，“]”四种。

#include <stdio.h>#include <malloc.h>#define OK 1#define ERROR 0//定义顺序堆栈#define STACK_SIZE 100 //存储空间初始分配量#define STACK_INC 10 //存储空间分配增量/*typedef char Elem;*/typedef struct{char *base; //栈底指针char *top; //栈顶指针int size; //当前已分配的存储空间}SqStack;/*typedef int Status;*///创建空堆栈,栈顶指针和栈底指针相等时,栈为空int CreatStack(SqStack &S){S.base=(char *)malloc(STACK_SIZE*sizeof(char));S.top=S.base;S.size=STACK_SIZE;return OK;}//堆栈是否为空int StackEmpty(SqStack S){if(S.top!=S.base) return ERROR;return OK;}//进栈int Push(SqStack &S,char e){if(S.top-S.base>=S.size){ //栈满,追加存储空间S.base=(char *)realloc(S.base,(S.size+STACK_INC)*sizeof(char));S.top=S.base+S.size;S.size+=STACK_INC;}*S.top=e;S.top+=1;return OK;}//出栈int Pop(SqStack &S,char &e){if(S.top==S.base) return ERROR;S.top-=1;e=*S.top;return OK;}//括号匹配int Bracket(SqStack &S,char *str){int i=0,flag1=0,flag2;char e;while(str[i]!='\0'){switch(str[i]){case '(':Push(S,'(');break; //'('进栈case '[':Push(S,'[');break; //'['进栈case ')':{Pop(S,e);if(e!='(') flag1=1; break;} //出栈，判断是否为'(' case ']':{Pop(S,e);if(e!='[') flag1=1;break;} //出栈，判断是否为'[' default: break;}if(flag1) break; //出现不匹配，立即结束循环i++;}flag2=StackEmpty(S); //flag2判断堆栈是否为空if(!flag1 && flag2) printf("括号匹配!\n");else printf("括号不匹配!\n");return OK;}//主函数void main(){char temp,flag='y';while(flag=='y'){char str[255];SqStack S;printf("请输入字符串:");scanf("%s",str);scanf("%c",&temp); //接受输入的回车键CreatStack(S);Bracket(S,str);printf("你想再试一次吗(按y继续): ");scanf("%c",&flag);printf("\n");}printf("程序结束.\n");}。

数据结构实验表达式括号匹配配对判断问题.

实验表达式括号匹配配对判断问题姓名：班级：学号：实验时间：1.问题描述一个算术表达式含圆括号、中括号、花括号,且它们可任意嵌套使用。

写一程序，判断任一算术表达式中所含括号是否正确配对。

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

因此用栈来解决。

#define stacksize 100 //定义栈的空间大小structstack{ //定义栈的结构体char strstack[stacksize];//定义栈的存储格式为字符型 int top; //定义栈的栈顶变量};void InitStack(stack &s){//定义一个新栈s，初始化栈顶为-1s.top = -1;}3.算法设计（1）入栈的算法char Push(stack &s, char a){ //入栈操作，将字符a入栈sif(s.top == stacksize - 1) //当栈顶为栈的空间大小-1，栈满 return 0;s.top ++;//入栈操作一次，栈顶+1s.strstack[s.top] = a;//此时，栈顶元素为字符areturn a;}（2）出栈的算法设计char Pop(stack &s ){ //出栈操作if(s.top == -1) //当栈顶为-1时，栈空return 0;char a = s.strstack[s.top];//将栈顶元素赋予字符a，并返回字符a，完成出栈操作s.top--;return a;}（3）判断栈是否为空的函数int Empty(stack &s,int re){ //定义判断栈是否为空的函数if(s.top==-1)return 1;//栈为空时返回值为1elsereturn 0;//栈不为空时返回值为0}（4）判断是否匹配的算法。

如果右括号，进栈，取下个字符；如果是左括号，出栈，取下个字符；最后判断栈是否为空。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

括号配对问题实验报告(3篇)

第1篇一、实验目的本研究旨在探讨括号配对问题（Balanced Parentheses Problem）的解决策略，分析不同背景知识、认知风格和问题解决经验对括号配对问题解决的影响，以期为相关教学和实践提供参考。

二、实验背景括号配对问题是一种典型的逻辑推理问题，主要考察个体对括号结构的理解和运用能力。

在计算机科学、数学、逻辑学等领域中，括号配对问题具有广泛的应用。

然而，由于括号配对问题的复杂性，许多人难以在短时间内解决此类问题。

因此，研究括号配对问题的解决策略具有重要的理论意义和实际应用价值。

三、实验方法1. 实验对象：选取60名大学生作为实验对象，随机分为三组，每组20人。

其中，A组为计算机科学专业学生，B组为数学专业学生，C组为非计算机及数学专业学生。

2. 实验材料：设计50道括号配对问题，分为易、中、难三个难度级别，每级各15道题。

3. 实验步骤：（1）对实验对象进行分组；（2）对实验对象进行括号配对问题解决能力测试，包括易、中、难三个难度级别的题目；（3）收集实验数据，分析不同背景知识、认知风格和问题解决经验对括号配对问题解决的影响。

四、实验结果与分析1. 不同背景知识对括号配对问题解决的影响A组学生在易、中、难三个难度级别的括号配对问题解决中均优于B组和C组。

这说明计算机科学专业学生在括号配对问题解决方面具有明显优势。

2. 认知风格对括号配对问题解决的影响在易、中、难三个难度级别的括号配对问题解决中，A组和B组学生的直觉型认知风格与逻辑型认知风格无明显差异。

然而，C组学生的直觉型认知风格在易、中、难三个难度级别的括号配对问题解决中均低于逻辑型认知风格。

3. 问题解决经验对括号配对问题解决的影响A组和B组学生在易、中、难三个难度级别的括号配对问题解决中均优于C组。

这说明问题解决经验在括号配对问题解决中具有重要作用。

五、结论与建议1. 结论（1）括号配对问题解决能力与个体背景知识、认知风格和问题解决经验密切相关；（2）计算机科学专业学生在括号配对问题解决方面具有明显优势；（3）问题解决经验在括号配对问题解决中具有重要作用。

实验三实验报告括号匹配的检验

实验三实验报告括号匹配的检验实验题⽬：括号匹配的检验⼀、实验⽬的加深理解栈的定义和特性；掌握栈的存储结构与实现⼆、实验内容：任意输⼊⼀个由若⼲个圆括号、⽅括号和花括号组成字符串，设计⼀个算法判断该串中的括号是否配对。

三、设计与编码1、基本思想基本思想：最内层(最迟出现)的左刮号必须与最内层(最早出现)的同类右刮号配对，它最急切地期待着配对。

配对之后, 期待得以消解。

因此为左刮号设置⼀个栈，置于栈顶的左刮号期待配对的急切程度最⾼。

实例：[ ( [ ] { } ) ]、( [ { } ] )、{ [ ] } )、( { [ ] }、( { [ ] ] )2、编码#include#includeconst int StackSize=100;class SeqStack{public:SeqStack(){top=-1;}~SeqStack(){}void Push(char s);char Pop();void Peidui(char s[StackSize]);private:char data[StackSize];int top;};void SeqStack::Push(char s){if(top==StackSize-1) throw"上溢";top++;data[top]=s;char SeqStack::Pop(){if(top==-1)throw"下溢";else{char a;a=data[top--];return a;}}void SeqStack::Peidui(char *s){int i=0,l=strlen(s);char t;for(i=0;i{if(s[i]=='{'||s[i]=='['||s[i]=='(')Push(s[i]);else{if(top==-1){cout<<"右括号多了,不匹配"<return;}else{t=data[top];if(t=='{'&&s[i]=='}'||t=='['&&s[i]==']'||t=='('&&s[i]==')') {Pop();}elsebreak;}}if(top==-1&&s[i]=='\0')cout <<"配对成功"<elseif(top!=-1&&s[i]=='\0')cout<<"左括号多了,不匹配"<elsecout<<"左右类型不匹配"<}void main(){char str[10];cout<<"请输⼊括号；"<cin>>str;SeqStack S;S.Peidui(str);}四、调试与运⾏1、调试时遇到的主要问题及解决2、运⾏结果（输⼊及输出，可以截取运⾏窗体的界⾯）五、实验⼼得。

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)为了实现上述程序功能，需要：[1]建⽴⼀个顺序栈；[2]键盘输⼊⼀个表达式，并对其进⾏扫描；[3]当扫描到“（”就进⾏⼊栈操作，遇到“）”就将栈顶元素出栈，扫描到其他元素不进⾏任何操作；[4]扫描完表达式，判断栈是否为空。

若为空，则匹配正确，反之错误。

2)本程序包含的函数：[1]主函数main()[2]void Bracket()四、详细设计1)定义顺序栈类型Typedefstruct{Char stack[StackMaxSize];Int top;}Stack;2） [1]⾸先将定义⼀个栈S置成空栈，InitStack(S)；[2]然后在main()⾥定义字符串str[100],并将其输⼊gets(str)；[3]接着利⽤while（str[i]!=’\0’）语句对字符串进⾏扫描[4]如果遇到“（“就执⾏push(S,’(‘)操作，遇到”)“就进⾏删除栈顶元素操作；[5]最后判断栈是否为空，StackEmpty(S)。

五、调试分析在⼀开始的试验中，在判断括号是否判断正确的if语句中if(!flag1&&flag2),这样得到的结果就不正确了，如图：解决⽅法：将判断括号配对是否正确的if语句中if(!flag1&&flag2)改为if（！flag2）这样只要判断flag2标志的栈是否为空，从⽽得到括号是否配对正确。

六、测试结果：1）测试数据：4+（4+5），））（（，）+（），）+（）+（2）测试结果截图：七、附录（源代码）#includevoid Bracket(char *str);void main()//主函数{char str[100];//定义⼀个字符串printf("please input:");gets(str);Bracket(str);}#define StackMaxSize 100 typedefstruct{//定义⼀个顺序栈类型char stack[StackMaxSize]; int top;}Stack;Stack *InitStack(Stack *S)//置空栈{S->top=-1;return S;}intStackEmpty(Stack *S)//判栈空{return S->top==-1;}char Pop(Stack *S,char *a)//顺序栈取栈顶元素{*a=S->top;if(S->top<=StackMaxSize-1&&S->top>=0) return(S->stack[S->top]);elseprintf("error");}void Push(Stack *S,charstr){//顺序栈⼊栈if(S->toptop>=-1){ S->top++;S->stack[S->top]=str;}elseprintf("error");}void Bracket(char *str){Stack S1,*S=&S1char a;inti=0,flag1=0,flag2;InitStack(S);while(str[i]!='\0'){switch(str[i]){case '(':Push(S,'(');break;case ')':Pop(S,&a);if(a!='('){flag1=1;break;//出现不匹配，⽴即结束循环}default:break;}if(flag1)break;i++;}flag2=StackEmpty(S);//flag2判断堆栈是否为空if(!flag2) printf("括号匹配正确\n");elseprintf("括号匹配不正确\n");}。

括号匹配问题栈c语言实验报告

括号匹配问题栈c语言实验报告
一、实验目的
(1)掌握用C语言调试程序的基本方法。

(2)掌握栈的基本定义及其存储实现。

(3)掌握栈的常见算法的程序实现。

(4)掌握栈在实际问题背景下的灵活应用。

二、实验内容
算术表达式中右括号和左括号匹配的次序正好符合后到括号要最先被匹配的“后进先出”堆栈操作特点，因此可以借用一个堆栈来进行判断。

具体方法：
⑴顺序扫描算术表达式（表现为一个字符串）；
⑵当遇到三种类型的左括号时，让该括号进栈；
⑶当遇到某一种类型的右括号时，比较当前栈顶括号是否与之匹配，
⑷若匹配则退栈，转（1）继续进行判断；
⑸若不匹配，则左右括号配对次序不正确，结束。

⑹若字符串当前为某一类型的右括号而堆栈为空，则右括号多于左括号，结束。

⑺若字符串扫描结束而堆栈非空，则左括号多于右括号，结束。

⑻若字符串扫描结束而堆栈为空，则左右括号匹配正确，结束。

三、实验要求
(1)程序要添加适当的注释，程序的书写要采用缩进格式。

(2)程序要具备一定的健壮性，即当输入数据非法时，程序也能适当地做出反应。

(3)程序要做到界面友好，在程序运行时用户可以根据相应的提示信息进行操作。

(4)根据实验报告模板详细书写实验报告（程序调试成功的，需将运行结果截图附在实验报告里面；实验报告以pdf格式或者.doc格式/.docx格式上传）。

(5)将源程序(.c或者.cpp)压缩为一个文件（如果自定义了读、写文件则一起压缩）上传，扩展名为：.rar或.zip。

四、实验环境
Windows 10，Microsoft Visual C++2010 Express。

括号匹配检测实验报告

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

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

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

括号匹配实验报告

括号匹配实验报告实验报告课程名称：数据结构班级：实验成绩：实验名称：栈、队列、字符串和数组学号：批阅教师签字：实验编号：实验⼆姓名：实验⽇期：指导教师：组号：实验时间：⼀、实验⽬的（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;

数据结构括号匹配检验

《数据结构与算法》课程设计报告题目：括号匹配检验四．算法思想利用栈来判断括号是否匹配时，遇到左括号就进栈，遇到右括号则左括号出栈，代表这对括号匹配，如果右括号进栈时，栈为空，则说明缺少左括号，若表达式扫描完栈为空，则说明表达式的括号匹配，否则说明表达式缺少左括号。

五．算法设计程序流程图算法用到的抽象数据类型定义：1．ADT Stack{数据对象：D={a i|a i∈ElemSet,i=1,2，…，n, n≥0}数据关系：R1={<a i-1,a i>|a i-1,a i∈D,i=2, …,n}约定a n端为栈顶，a1端为栈底。

基本操作：（1）I nitStack(&S)；操作结果：构造一个空栈S。

（2）S tackEmpty(S)；初始条件：栈S已存在。

操作结果：若栈S为空栈，则返回TURE，否则FALUSE。

（3）S tackFull(S)；初始条件：栈S已存在。

操作结果：若栈S为满，则返回TURE,否则FALUSE.（4）G etTop(S,&e)；初始条件：栈S已存在且非空。

操作结果：用e返回S的栈顶元素。

（5）P ush(&S,e)；初始条件：栈S已存在。

操作结果：插入元素e为新的栈顶元素。

（6）P op(&S,&e)；初始条件：栈S已存在且非空。

操作结果：删除S的栈顶元素，并用e返回其值。

}ADT Stack∙算法中函数编号及功能要求：1.voidInitStack(SeqStack*S)：初始化，构造一个空栈S2.IsEmpty(SeqStack *S)：判断栈S为空栈时返回值为真，反之为假3.IsFull(SeqStack *S)：判断栈S为满栈时返回值为真，反之为假4.Push(SeqStack *S,StackElementType x)：插入元素x为新的栈顶元素5.Pop(SeqStack *S,StackElementType *x)：将栈S的栈顶元素弹出，放到x所指的存储空间中6.GetTop(SeqStack *S,StackElementType *x)：将栈S的栈顶元素弹出，放到x所指的存储空间中，但栈顶指针保持不变7.Match(char ch,char str)：进行括号的匹配8.BracketMatch(char *str)： str[]中为输入的字符串，利用堆栈技术来检查该字符串中的括号是否匹配∙函数之间的调用关系（子程序编号见上）：主函数调用函数8函数8调用函数1、2、4、5、6、7六．C语言实现的程序清单/*******括号匹配的检验********/#define TRUE 1#define FALSE 0#define Stack_Size 50#define StackElementType char#include "stdio.h"/*顺序栈*/typedef struct{StackElementType elem[Stack_Size]; /*用来存放栈中元素的一维数组*/int top; /*用来存放栈顶元素的下标，top为-1表示空栈*/}SeqStack;/*初始化*/void InitStack(SeqStack *S){/*构造一个空栈S*/S->top = -1;}/*判栈空*/int IsEmpty(SeqStack *S) /*判断栈S为空栈时返回值为真，反之为假*/{return(S->top==-1?TRUE:FALSE);}/*判栈满*/int IsFull(SeqStack *S) /*判断栈S为满栈时返回值为真，反之为假*/{return(S->top==Stack_Size-1?TRUE:FALSE);}int Push(SeqStack *S,StackElementType x){if(S->top==Stack_Size-1)return(FALSE); /*栈已满*/S->top++;S->elem[S->top] = x;return(TRUE);}int Pop(SeqStack *S,StackElementType *x){/* 将栈S的栈顶元素弹出，放到x所指的存储空间中*/if(S->top == -1) /*栈为空*/return(FALSE);else{*x = S->elem[S->top];S->top--; /* 修改栈顶指针*/return(TRUE);}}/*取栈顶元素。

括号配对检验实验报告

括号配对检验实验报告实验目的本实验的目的是设计一个算法，用于检验一个字符串中的括号是否配对。

实验原理在数学、编程等领域，我们会经常使用括号来表示不同层次的结构。

但是在实际应用中，很容易出现括号的不配对错误，从而导致程序逻辑错误或结果不符合预期。

因此，设计一个算法来检验括号的配对情况是非常有意义的。

本实验使用栈的数据结构来实现括号配对的检验。

栈是一种具有后进先出（Last In First Out，简称LIFO）特点的数据结构，可以用于解决需要后操作的优先级问题。

当遍历字符串中的括号时，我们将左括号（例如“（”、“[”、“{”）压入栈中，当遇到右括号（例如“）”、“]”、“}”）时，我们将栈顶的元素弹出，并比较右括号与弹出的左括号是否匹配。

如果匹配，则继续遍历；如果不匹配，则返回“括号不配对”。

最后，如果栈为空，说明所有的括号都成功匹配，返回“括号配对”。

实验过程首先，我们需要实现一个栈数据结构。

栈可以使用数组或链表来实现，本实验选择使用数组来实现。

定义一个整数变量`top`，代表栈顶元素的索引；定义一个整数数组`stack`存储栈中的元素。

接下来，我们遍历输入字符串中的每个字符。

当遇到左括号时，将其压入栈中；当遇到右括号时，将栈顶元素弹出，并比较两个括号是否配对。

如果不配对，则返回“括号不配对”。

最后，如果栈为空，则返回“括号配对”；否则，返回“括号不配对”。

实验结果为了验证算法的正确性，我们对不同的字符串进行了测试，下面是实验结果：测试1输入字符串：`()`实验结果：括号配对测试2输入字符串：`({})`实验结果：括号配对测试3输入字符串：`((]`实验结果：括号不配对测试4输入字符串：`{[()]}`实验结果：括号配对测试5输入字符串：`{[()]})`实验结果：括号不配对实验结论通过测试结果可以看出，本实验设计的括号配对检验算法能够正确检测括号的配对情况。

算法的时间复杂度为O(n)，其中n为字符串的长度。

括号匹配实验数据结构

实验二括号匹配1.需求和规格说明判断输入的表达式中的括号（包含大括号、中括号、小括号）是否匹配。

程序用MFC实现。

2.设计2.1．设计思想主要通过栈来实现。

先接受用户输入的表达式，过滤掉除括号以外的字符，通过栈匹配。

当是左边括号时，进行压栈。

当是右边括号时，是否与栈顶元素匹配（相应的左括号）。

如果匹配，则出栈，并继续进行下一轮匹配。

如果不匹配，则销毁栈，返回不匹配信息。

2.2．设计表示(1)存储结构typedef struct{char *base;char *top;int stacksize;}SqCharStack;(2)涉及的操作int InitCharStack(SqCharStack &S) //初始化栈。

int DestroyCharStack(SqCharStack &S) //销毁栈。

int CharGetTop(SqCharStack S, char &e) //获取栈顶元素。

int CharPush(SqCharStack &S, char e) //压栈。

int CharPop(SqCharStack &S, char &e) //出栈。

int CTest2Dlg::Correct(const char *express) //括号匹配核心处//理函数。

2.3．实现注释(1)参数说明：InitCharStack(SqCharStack &S)函数参数是要初始化的栈。

通过动态方式分配存储空间。

DestroyCharStack(SqCharStack &S)函数参数是要销毁的栈。

释放动态分配的空间。

CharGetTop(SqCharStack S, char &e)函数第一个参数为被获取的值的栈，第二个参数接受获取的栈顶元素的值。

CharPush(SqCharStack &S, char e)函数第一个参数为栈，第二个参数接受出栈元素的值。

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

括号的匹配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;elsereturn TRUE;}virtual ~MyListStack() //析构链栈，释放空间。

课程设计报告——括号匹配问题

课程设计报告——括号匹配问题1. 设计目的1、能根据实际问题的具体情况，结合数据结构课程中的基本理论和基本算法，分析并正确确定数据的逻辑结构，合理地选择相应的存储结构，并能设计出解决问题的有效算法。

2、提高程序设计和调试能力。

学生通过上机实习，验证自己设计的算法的正确性。

学会有效利用基本调试方法，迅速找出程序代码中的错误并且修改。

3、初步掌握软件开发过程中问题分析、系统设计、程序编码、测试等基本方法和技能。

4、训练用系统的观点和软件开发一般规范进行软件开发，培养软件工作者所应具备的科学的工作方法和作风。

5、培养根据选题需要选择学习书籍，查阅文献资料的自学能力。

2. 设计内容2.1 系统名称括号匹配问题：括号匹配问题就是给定任意判别式，然后检验括号的配对出现的情况。

2.2要求假设一个算术表达式中可包含三种括号：圆括号、中括号、花括号且这三种括号可按任意次序嵌套使用。

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

任意运用一种计算机语言，分析问题，写出具体程序，要求能够在对应的系统中实现该问题的，实验通过计算机来完成。

独立完成，可通过查阅资料来解决自己不会的问题，提高自己查阅文献的能力级独立思考的能力。

3．程序设计步骤3.1程序流程分析图图3-1 程序流程图3.2主要的数据结构类型typedef struct{int top;char Szstack[MaxSize];}Text;3.3 程序功能模块函数(1) 检验栈是否为空bool IsEmpty(Text G){if(G.top==-1)return true;elsereturn false;}(2) 检验栈是否为满bool IsFull(Text G){if(G.top==MaxSize-1)return true;elsereturn false;}( top=%d \n\n",G.top);break;case'[':G.Szstack[++(G.top)]=c;printf(" 压入[ top=%d \n\n",G.top);break;case'{':G.Szstack[++(G.top)]=c;printf(" 压入{ top=%d \n\n",G.top);break;case')':if(Pop(G)!='('){return 0;}else{G.Szstack[G.top--];printf(" 当遇) 出栈( top=%d\n\n",G.top);break;}case']':if(Pop(G)!='[')return 0;else{G.Szstack[G.top--];printf(" 当遇] 出栈[ top=%d\n\n",G.top);break;}case'}':if(Pop(G)!='{')return 0;else{G.Szstack[G.top--];printf(" 当遇} 出栈{ top=%d\n\n",G.top);break;}default:break;}}if(!IsEmpty(G))return 0;return 1;}3.4程序实现中函数之间的调用先进行函数声明，在定义函数，再在功能函数及主函数中调用函数，实现检验括号匹配的问题。