实验 表达式括号匹配配对判断问题

实验  表达式括号匹配配对判断问题
实验  表达式括号匹配配对判断问题

实验表达式括号匹配配对判断问题

姓名:贾柯柯班级:计162

学号:1613023052 实验时间:2017.10.28

1.问题描述

一个算术表达式含圆括号、中括号、花括号,且它们可任意嵌套使用。写一程序,判断任一算术表达式中所含括号是否正确配对。

2.数据结构设计

匹配判别发生在右括号出现时,且被匹配的左括号应是距离右括号最近被输入的,二不是最先被输入的括号,即“先入后匹配”。因此用栈来解决。

#define stacksize 100 //定义栈的空间大小

struct

stack{ //定义栈的结构体

char strstack[stacksize];//定义栈的存储格式为字符型

int top; //定义栈的栈顶变量

};

void InitStack(stack &s)

{//定义一个新栈s,初始化栈顶为-1

s.top = -1;

}

3.算法设计

(1)入栈的算法

char Push(stack &s, char a)

{ //入栈操作,将字符a入栈s

if(s.top == stacksize - 1) //当栈顶为栈的空间大小-1,栈满

return 0;

s.top ++;//入栈操作一次,栈顶+1

s.strstack[s.top] = a;//此时,栈顶元素为字符a

return 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;//栈为空时返回值为1

else

return 0;//栈不为空时返回值为0

}

(4)判断是否匹配的算法。如果右括号,进栈,取下个字符;如果是左括号,出栈,取下个字符;最后判断栈是否为空。

int Check(char* str)

{ //检验括号是否匹配的函数

stack s;

InitStack(s);

int strn = strlen(str); //定义字符串长度为strn

for(int i=0;i

{

char a=str[i];

int re=0;

switch(a)

{//对输入的字符a进行判断

case '(':

case '{':

case '[':

Push(s,a);//若是左括号,则进行入栈操作

break;

//若是右括号,则进行出栈操作,若出栈元素不是与输入相对应的左括号,则字符串括号中不匹配,返回

case ')':

if(Pop(s)!='(')

return 0;

break;

case '}':

if(Pop(s)!='{')

return 0;

break;

case ']':

if(Pop(s)!='[')

return 0;

break;

}

}

int re=0; //定义并初始化判空函数的返回值

re=Empty(s,re); //返回判空函数的返回值

if(re==1)

return 1; //栈为空

else

return 0; //栈不为空,有左括号,存在'('或'['或'{'未匹配

}

4.运行与测试

①输入1+(2+3).

②输入1+(2+3))

③输入1+((2+3)

④输入1+2+3+4

⑤输入1+[2+(4-2])*2

5.调试记录及收获

在运行程序时,当输入1+((2+3)时,因为错把’(’写成’(’,也就是输入法的中英文没有切换,所以得到的结果是错的。这就说明输入时要注意中英文。

通过本次实验,我对栈的使用更加熟练,入栈出栈的顺序也有了更一步的了解。

数据结构实验报告全集

数据结构实验报告全集 实验一线性表基本操作和简单程序 1.实验目的 (1)掌握使用Visual C++ 6.0上机调试程序的基本方法; (2)掌握线性表的基本操作:初始化、插入、删除、取数据元素等运算在顺序存储结构和链表存储结构上的程序设计方法。 2.实验要求 (1)认真阅读和掌握和本实验相关的教材内容。 (2)认真阅读和掌握本章相关内容的程序。 (3)上机运行程序。 (4)保存和打印出程序的运行结果,并结合程序进行分析。 (5)按照你对线性表的操作需要,重新改写主程序并运行,打印出文件清单和运行结果 实验代码: 1)头文件模块 #include iostream.h>//头文件 #include//库头文件-----动态分配内存空间 typedef int elemtype;//定义数据域的类型 typedef struct linknode//定义结点类型 { elemtype data;//定义数据域 struct linknode *next;//定义结点指针 }nodetype; 2)创建单链表

nodetype *create()//建立单链表,由用户输入各结点data域之值,//以0表示输入结束 { elemtype d;//定义数据元素d nodetype *h=NULL,*s,*t;//定义结点指针 int i=1; cout<<"建立一个单链表"<> d; if(d==0) break;//以0表示输入结束 if(i==1)//建立第一个结点 { h=(nodetype*)malloc(sizeof(nodetype));//表示指针h h->data=d;h->next=NULL;t=h;//h是头指针 } else//建立其余结点 { s=(nodetype*) malloc(sizeof(nodetype)); s->data=d;s->next=NULL;t->next=s; t=s;//t始终指向生成的单链表的最后一个节点

堆栈应用

1引言 本课程主要是对栈的一些基本操作以及栈的应用进行设计的,栈是操作受限的线性表,先进后出,可称为限定性的数据结构]1[。栈的基本操作包括栈的初始化,进栈操作、出栈操作、取栈顶元素、判读栈是否为空、判断栈是否满以及对栈的置空,通过这些基本操作的组合来实现进制转换、括号匹配、文本输入。 2问题分析 2.1进制转换 将一个十进制的数转换为另一进制,基于数的组成原理位权与进制,转换时让十进制数除以该进制,得到的便是最低位上的数,用得到的商再除以该进制则得到次低位上的数,依次循环下去直到得到的商为0;进制转换完毕,可以看出我们得到首先的是最低位,而数据的书写形式是从高位到低位,所以选择栈的存储结构先进后出,得到的余数顺序进栈,等到结束再顺序出栈输出,这时就是我们先要的结果。 2.2括号匹配 括号匹配是对于一组括号的判断,当输入一个左括号时,它就会等待与之相应的右括号出现,如果等来的却是另一个左括号,那么这时最迫切等待的是刚输入的那个左括号,它会等待与之相应的右括号出现。如果等来了与之相应的右括号,那么它得到了匹配,现在迫切等待的是它之前的左括号,可以看出先进去的左括号迫切需要的程度没后来进去的左括号强,后来者居上,我们选择栈的存储结构,先来的括号进栈,栈顶元素是需要程度最强的,得到了匹配则退栈。 2.3文本输入 文本输入是对于文章来说的,而输入文本时时常会出错,当输入特定的字符时我们会删除该行最后的文字,当错误太多时我们会整行删除,输入特定字符时换行。可以看出这些操作都是在文本的最后执行,所以我们也选择栈存储结构,输入一个字符进栈,输入特定的字符1让栈顶元素出栈,输入特定字符2,则将栈清空。如果栈满,则将文本输出,并且置空,接受下一行的文本,直到输入结束。 由于三种功能用到栈的类型一样,所以我们定义一个类型栈就可以了,栈的定义,如下: typedef char status; typedef struct { status *base; status *top; int stacksize; }sqstack;

正则表达式

1.验证用户名和密码:("^[a-zA-Z]\w{5,15}$")正确格式:"[A-Z][a-z]_[0-9]"组成,并且第一个字必须为字母6~16位; 2.验证电话号码:("^(\d{3,4}-)\d{7,8}$")正确格式:xxx/xxxx-xxxxxxx/xxxxxxxx; 3.验证手机号码:"^1[3|4|5|7|8][0-9]\\d{8}$"; 4.验证身份证号(15位或18位数字):"\d{14}[[0-9],0-9xX]"; 5.验证Email地址:("^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$"); 6.只能输入由数字和26个英文字母组成的字符串:("^[A-Za-z0-9]+$"); 7.整数或者小数:^[0-9]+([.][0-9]+){0,1}$ 8.只能输入数字:"^[0-9]*$"。 9.只能输入n位的数字:"^\d{n}$"。 10.只能输入至少n位的数字:"^\d{n,}$"。 11.只能输入m~n位的数字:"^\d{m,n}$"。 12.只能输入零和非零开头的数字:"^(0|[1-9][0-9]*)$"。 13.只能输入有两位小数的正实数:"^[0-9]+(\.[0-9]{2})?$"。 14.只能输入有1~3位小数的正实数:"^[0-9]+(\.[0-9]{1,3})?$"。 15.只能输入非零的正整数:"^\+?[1-9][0-9]*$"。 16.只能输入非零的负整数:"^\-[1-9][0-9]*$"。 17.只能输入长度为3的字符:"^.{3}$"。 18.只能输入由26个英文字母组成的字符串:"^[A-Za-z]+$"。 19.只能输入由26个大写英文字母组成的字符串:"^[A-Z]+$"。 20.只能输入由26个小写英文字母组成的字符串:"^[a-z]+$"。 21.验证是否含有^%&',;=?$\"等字符:"[%&',;=?$\\^]+"。 22.只能输入汉字:"^[\u4e00-\u9fa5]{0,}$"。 23.验证URL:"^http://([\w-]+\.)+[\w-]+(/[\w-./?%&=]*)?$"。 24.验证一年的12个月:"^(0?[1-9]|1[0-2])$"正确格式为:"01"~"09"和"10"~"12"。 25.验证一个月的31天:"^((0?[1-9])|((1|2)[0-9])|30|31)$"正确格式为;"01"~"09"、"10"~"29"和“30”~“31”。 26.获取日期正则表达式:\\d{4}[年|\-|\.]\d{\1-\12}[月|\-|\.]\d{\1-\31}日? 评注:可用来匹配大多数年月日信息。 27.匹配双字节字符(包括汉字在内):[^\x00-\xff] 评注:可以用来计算字符串的长度(一个双字节字符长度计2,ASCII字符计1) 28.匹配空白行的正则表达式:\n\s*\r 评注:可以用来删除空白行 29.匹配HTML标记的正则表达式:<(\S*?)[^>]*>.*?|<.*? /> 评注:网上流传的版本太糟糕,上面这个也仅仅能匹配部分,对于复杂的嵌套标记依旧无能为力 30.匹配首尾空白字符的正则表达式:^\s*|\s*$

数据结构课程设计---括号匹配

目录 1 问题描述 (2) 1.1题目 (2) 1.2问题 (2) 1.3要求 (2) 2 设计 (2) 2.1存储结构设计 (2) 2.2主要算法设计 (3) 2.3测试用例及测试结果 (6) 3 调试报告 (9) 4 对设计和编码的讨论和分析 (20) 4.1设计 (20) 4.2对编码的讨论 (21) 5 总结和体会 (22) 附录一 (24) 本科生课程设计成绩评定表................... 错误!未定义书签。

数据结构课程设计 ——判别括号配对 1问题描述 1.1题目: 判别括号配对 1.2问题: 一个算术表达式含圆括号、中括号、花括号,且它们可任意嵌套使用。写一程序,判断任一算术表达式中所含括号是否正确配对。 1.3要求: (1)表达式从键盘输入。 (2)利用栈求解此问题。 (3)测试用例自己设计。 2设计 2.1存储结构设计 题目要求利用栈来求解此问题,因此选择顺序栈作为存储结构,具体表示如下: #define STACK_INIT_SIZE 100 #define STACKINCREMENT 10

char *base; char *top; int stacksize; }SqStack; 2.2主要算法设计 2.2.1算法思想 (1)文字描述 从键盘输入一个表达式; 逐个扫描表达式中的字符; 当遇到左括号时,将左括号入栈; 继续扫描,将此后遇到的第一个右括号与栈顶元素比较,若匹配,则栈顶元素出栈;否则,继续扫描; 当整个表达式扫描完以后,判断栈内是否还有元素,若有,则括号不匹配; 若栈为空,则括号配对成功; 在括号配对不成功的情况下,利用栈顶栈底元素的差值,可以对左右括号数进行比较。(2)流程图表示

实验二 堆栈和队列基本操作的编程实现

实验二堆栈和队列基本操作的编程实现 【实验目的】 堆栈和队列基本操作的编程实现 要求: 堆栈和队列基本操作的编程实现(2学时,验证型),掌握堆栈和队列的建立、进栈、出栈、进队、出队等基本操作的编程实现,存储结构可以在顺序结构或链接结构中任选,也可以全部实现。也鼓励学生利用基本操作进行一些应用的程序设计。 【实验性质】 验证性实验(学时数:2H) 【实验内容】 内容: 把堆栈和队列的顺序存储(环队)和链表存储的数据进队、出队等运算其中一部分进行程序实现。可以实验一的结果自己实现数据输入、数据显示的函数。 利用基本功能实现各类应用,如括号匹配、回文判断、事物排队模拟、数据逆序生成、多进制转换等。 【思考问题】 1.栈的顺序存储和链表存储的差异? 2.还会有数据移动吗?为什么? 3.栈的主要特点是什么?队列呢? 4.栈的主要功能是什么?队列呢? 5.为什么会有环状队列? 【参考代码】 (一)利用顺序栈实现十进制整数转换转换成r进制 1、算法思想 将十进制数N转换为r进制的数,其转换方法利用辗转相除法,以N=3456,r=8为例转换方法如下: N N / 8 (整除)N % 8(求余) 3456 432 0 低 432 54 0 54 6 6 6 0 6 高 所以:(3456)10 =(6600)8 我们看到所转换的8进制数按底位到高位的顺序产生的,而通常的输出是从高位到低位的,恰好与计算过程相反,因此转换过程中每得到一位8进制数则进栈保存,转换完毕后依次出栈则正好是转换结果。 算法思想如下:当N>0时重复1,2 ①若N≠0,则将N % r 压入栈s中,执行2;若N=0,将栈s的内容依次出栈,算法结束。 ②用N / r 代替N 2、转换子程序

正则表达式

本文分十四个类别对正则表达式的意义进行了解释,这十四各类别是:字符/字符类/预定义字符类/POSIX字符类/https://www.360docs.net/doc/4b12593443.html,ng.Character类/Unicode块和类别的类/边界匹配器/Greedy数量词/Reluctant数量词/Possessive数量词/Logical运算符/Back引用/引用/特殊构造。 1.1.字符 x 字符 x。例如a表示字符a \\ 反斜线字符。在书写时要写为\\\\。(注意:因为java在第一次解析时把\\\\解析成正则表达式\\,在第二次解析时再解析为\,所以凡是不是1.1列举到的转义字符,包括1.1的\\,而又带有\的都要写两次) \0n 带有八进制值 0的字符 n (0 <= n <= 7) \0nn 带有八进制值 0的字符 nn (0 <= n <= 7) \0mnn 带有八进制值 0的字符 mnn(0 <= m <= 3、0 <= n <= 7) \xhh 带有十六进制值 0x的字符 hh \uhhhh 带有十六进制值 0x的字符 hhhh \t 制表符 ('\u0009') \n 新行(换行)符 ('\u000A') \r 回车符 ('\u000D') \f 换页符 ('\u000C') \a 报警 (bell) 符 ('\u0007') \e 转义符 ('\u001B') \cx 对应于 x 的控制符 1.2.字符类 [abc] a、b或 c(简单类)。例如[egd]表示包含有字符e、g或d。 [^abc] 任何字符,除了 a、b或 c(否定)。例如[^egd]表示不包含字符e、g或d。 [a-zA-Z] a到 z或 A到 Z,两头的字母包括在内(范围) [a-d[m-p]] a到 d或 m到 p:[a-dm-p](并集) [a-z&&[def]] d、e或 f(交集) [a-z&&[^bc]] a到 z,除了 b和 c:[ad-z](减去) [a-z&&[^m-p]] a到 z,而非 m到 p:[a-lq-z](减去) 1.3.预定义字符类(注意反斜杠要写两次,例如\d写为\\d) . 任何字符(与行结束符可能匹配也可能不匹配) \d 数字:[0-9] \D 非数字: [^0-9] \s 空白字符:[ \t\n\x0B\f\r] \S 非空白字符:[^\s] \w 单词字符:[a-zA-Z_0-9] \W 非单词字符:[^\w] 1.4.POSIX 字符类(仅 US-ASCII)(注意反斜杠要写两次,例如\p{Lower}写为\\p{Lower})

数据结构实验报告-串

实验四串 【实验目的】 1、掌握串的存储表示及基本操作; 2、掌握串的两种模式匹配算法:BF和KMP。 3、了解串的应用。 【实验学时】 2学时 【实验预习】 回答以下问题: 1、串和子串的定义 串的定义:串是由零个或多个任意字符组成的有限序列。 子串的定义:串中任意连续字符组成的子序列称为该串的子串。 2、串的模式匹配 串的模式匹配即子串定位是一种重要的串运算。设s和t是给定的两个串,从主串s的第start个字符开始查找等于子串t的过程称为模式匹配,如果在S中找到等于t的子串,则称匹配成功,函数返回t在s中首次出现的存储位置(或序号);否则,匹配失败,返回0。 【实验内容和要求】 1、按照要求完成程序exp4_1.c,实现串的相关操作。调试并运行如下测试数据给出运行结果: ?求“This is a boy”的串长; ?比较”abc 3”和“abcde“; 表示空格 ?比较”english”和“student“; ?比较”abc”和“abc“; ?截取串”white”,起始2,长度2; ?截取串”white”,起始1,长度7; ?截取串”white”,起始6,长度2; ?连接串”asddffgh”和”12344”; #include #include #define MAXSIZE 100 #define ERROR 0 #define OK 1 /*串的定长顺序存储表示*/

typedef struct { char data[MAXSIZE]; int length; } SqString; int strInit(SqString *s); /*初始化串*/ int strCreate(SqString *s); /*生成一个串*/ int strLength(SqString *s); /*求串的长度*/ int strCompare(SqString *s1,SqString *s2); /*两个串的比较*/ int subString(SqString *sub,SqString *s,int pos,int len); /*求子串*/ int strConcat(SqString *t,SqString *s1,SqString *s2); /*两个串的连接*/ /*初始化串*/ int strInit(SqString *s) { s->length=0; s->data[0]='\0'; return OK; }/*strInit*/ /*生成一个串*/ int strCreate(SqString *s) { printf("input string :"); gets(s->data); s->length=strlen(s->data); return OK; }/*strCreate*/ /*(1)---求串的长度*/ int strLength(SqString *s) { return s->length; }/*strLength*/ /*(2)---两个串的比较,S1>S2返回>0,s1length&&ilength;i++) { if(s1->data[i]>s2->data[i]) {

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

数据结构课程设计报告 设计题目:括号匹配 院系计算机学院 年级11 级 学生刘云飞 学号E01114295 指导教师王爱平 起止时间9-7/9-14

课程设计目的 1.熟悉并写出栈的逻辑结构表示 2.实现栈的存储表示 3.实现栈的操作 内容 括号匹配 课程设计要求 1.在实验报告中写出栈的ADT表示; 2.在实验报告中给出数据类型定义和核心算法和程序; 3.在实验报告中罗列实验过程中出现的问题和解决的方法; 4.打包上交调试后的完整程序,提交实验报告; 5.实验之前写出实验报告的大概框架,实验过程中填写完整。 6.实验时携带需要上机调试的程序; 7.实验评分:实验之前预习占20%,实验报告书写情况占50%,运行情况30%。概要设计 1.栈的ADT表示 ADT Stack{ 数据对象:D={ai|ai∈ ElemSet,i=1,2,…,n,n>=0} 数据关系:R1={|ai-1,ai ∈D,i=2,…,n} 约定an为栈顶端,a1为栈底端 基本操作: Status InitStack(&s) 操作结果:构造一个空栈s。 Status Push( &s, e) 初始条件:栈s已经存在。 操作结果:插入元素e为新的栈顶元素。 Status Pop( &s, &e) 初始条件:栈s已经存在,并不为空。 操作结果:删除s的栈顶元素,并用e返回其值。 Status Check( &s, e) 初始条件:栈s已经存在,并不为空。 操作结果:判断括号是否匹配。 Status EnterString( &s) }ADT Stack 2.数据类型定义和核心算法和程序 数据类型定义: typedef int Status;

堆栈应用括号匹配实验

深圳大学实验报告 课程名称:数据结构实验与课程设计 实验项目名称:堆栈应用括号匹配实验 学院:计算机与软件学院 专业:未分 指导教师:杨芳 报告人:姜家祥学号:2013150387 班级:08 实验时间:2013-10-9 实验报告提交时间:2014-10-10 教务处制

一、实验目的 掌握堆栈的基本原理 掌握堆栈的存储结构 掌握堆栈的进栈、弹栈、判断栈空的实现方法 掌握应用堆栈实现括号匹配的原理和实现方法 二、实验要求 熟悉C++语言编程 熟练使用C++语言实现堆栈的进栈Push、插入Pop、判断栈空等操作 熟练使用堆栈实现括号匹配算法 三、实验内容 本次实验有两项内容: (一)堆栈应用括号匹配 1、问题描述 一个算术表达式中包括圆括号、方括号和花括号三种形式的括号 编程实现判别表达式中括号是否正确匹配的算法 2、算法 顺序扫描算术表达式 若算术表达式扫描完成,此时如果栈空,则正确返回(0);如果栈未空,说明左括号多于右括号,返回(-3) 从算术表达式中取出一个字符,如果是左括号(‘(‘或‘[‘或‘{‘),则让该括号进栈(PUSH) 如果是右括号(‘)‘或‘]‘或‘}‘): ⑵ 、如果栈为空,则说明右括号多于左括号,返回(-2) ⑵、如果栈不为空,则从栈顶弹出(POP)一个括号:若括号匹配,则转1继续进行判断;否则,说明左右括号配对次序不正确,返回(-1) 3、输入 第一行:样本个数,假设为n。 第二到n+1行,每一行是一个样本(算术表达式串),共n个测试样本。 4、输入样本 4 {[(1+2)*3]-1} {[(1+2]*3)-1} (1+2)*3)-1} {[(1+2)*3-1] 5、输出 共有n行,每一行是一个测试结果,有四种结果: 0:左右括号匹配正确{[(1+2)*3]-1}

括号匹配检验

括号匹配检验,是假设表达式中允许包含两种括号:圆括号和方括号,其嵌套的顺序随意,即( [ ] ( ) )或[ ( [ ] )]等为正确的格式,[ ( ] )或( [ ( ))或( ( ) ] )均为不正确的格式。检验括号是否匹配的方法可用“期待的急迫程度”概念来描述。整个处理过程与栈的特点相吻合。因此此程序利用链表的头插法特点来完成。 #include "stdlib.h" #include "stdio.h" typedef struct Stack { char ch; struct Stack *next; }Stack,*StackList; char checkinput() /*检查输入数据的合理性*/ { char c; while(1) { printf("input the bracket:"); scanf("%c",&c); getchar(); if(c=='('||c==')'||c=='['||c==']') /*程序的有效性检测*/ break; else { printf("you input wrong! please input again!\n"); continue; } } return c; } int InitStack() /*创建栈的实例*/ { StackList L,s,t; char c; int i=0,n=0; L=(Stack*)malloc(sizeof(Stack));/*创建链表*/ L->next=NULL; while(1)

c=checkinput(); switch(c) { case '(': case '[': s=(Stack*)malloc(sizeof(Stack)); s->ch=c; s->next=L->next; /*头插法实现“栈”的功能*/ L->next=s; i=++n; /*n用来记录压入栈里的凡是左括号的数目*/ break; case ')': case ']': if(i==0) return 0; /*i用来判断第一次输入的括号是否为右括号,是则退出程序*/ t=L->next; if(t->ch+1==c) /*检查是否为'('和')',用他们的ACSII码值来检测*/ { L->next=t->next; /*匹配则删除栈顶元素*/ n--; printf("此项%c括号匹配!\n",t->ch); free(t); } else if(t->ch+2==c) /*检查是否为'['和']'*/ { L->next=t->next; /*匹配则删除栈顶元素*/ n--; printf("此项%c括号匹配!\n",t->ch); free(t); } else return 0; /*此语句判断输入两个括号后不匹配的结果,如'['和')'*/ break; } if(n==0) return 1; }

模式匹配KMP算法实验报告

实验四:KMP算法实验报告 一、问题描述 模式匹配两个串。 二、设计思想 这种由D.E.Knuth,J.H.Morris和V.R.Pratt同时发现的改进的模式匹配算法简称为KM P算法。 注意到这是一个改进的算法,所以有必要把原来的模式匹配算法拿出来,其实理解的关键就在这里,一般的匹配算法: int Index(String S,String T,int pos)//参考《数据结构》中的程序 { i=pos;j=1;//这里的串的第1个元素下标是1 while(i<=S.Length && j<=T.Length) { if(S[i]==T[j]){++i;++j;} else{i=i-j+2;j=1;}//**************(1) } if(j>T.Length) return i-T.Length;//匹配成功 else return 0; } 匹配的过程非常清晰,关键是当‘失配’的时候程序是如何处理的?为什么要回溯,看下面的例子: S:aaaaabababcaaa T:ababc aaaaabababcaaa ababc.(.表示前一个已经失配) 回溯的结果就是 aaaaabababcaaa a.(babc) 如果不回溯就是 aaaaabababcaaa aba.bc 这样就漏了一个可能匹配成功的情况 aaaaabababcaaa ababc 这是由T串本身的性质决定的,是因为T串本身有前后'部分匹配'的性质。如果T为a bcdef这样的,大没有回溯的必要。 改进的地方也就是这里,我们从T串本身出发,事先就找准了T自身前后部分匹配的位置,那就可以改进算法。 如果不用回溯,那T串下一个位置从哪里开始呢? 还是上面那个例子,T为ababc,如果c失配,那就可以往前移到aba最后一个a的位置,像这样:

括号匹配问题源代码(C语言)

括号匹配问题就是给定任意判别式,然后检验括号的配对出现的情况。 可见输入的表达式有四种可能性:右括号配对次序不正确、右括号多于左括号、左括号多于右括号、左右括号匹配正确。可以先检测表达式中的字符,若是左括号就入栈,如果是右括号就出栈一个元素与其配对,配对成功则继续访问下一个字符,否则退出。出现非括号字符则跳过。程序流程图如下:

程序代码如下: #include #include #include #include #define MaxSize 50 using namespace std; /*------------主要的数据结构类型 --------------*/ struct Text { int top; char Szstack[MaxSize]; }; /*-------------程序功能模块函数-------------*/ //检验栈是否为空 bool IsEmpty(Text G) { if(G.top==-1) return true; else return false; } //检验栈是否为满 bool IsFull(Text G) { if(G.top==MaxSize-1) return true; else return false; } //弹出栈顶元素 char Pop(Text G) { char n=G.Szstack[G.top]; return n; } //检验括号是否配对 int Check(char *A) { int i; Text G; G.top=-1; int L=strlen(A);

利用顺序栈实现括号匹配 c语言

#include #include //malloc,realloc #include //含有overflow #include //exit() #define S_SIZE 100 //栈的空间大小 #define STACKINCREAMENT 10//增加空间 struct SqStack{ int *base; //栈底 int *top; //栈顶 int stacksize; //栈当前的存储空间 }; void main() {//子函数声明 void InitStack(SqStack &S);//初始化空栈 int StackEmpty(SqStack S);//判空 void push(SqStack &S,int e);//进栈 void pop(SqStack &S,int &e);//出栈 //主函数开始 SqStack s;//初始化空栈 InitStack(s); char ch[100],*p;int e; p=ch; printf("输一个含义有()[]{}的括号表达式:\n"); gets(ch); while(*p) { switch (*p) { case '{': case '[': case '(': push(s,*p++);break;//只要是左括号就入栈 case '}': case ']': case ')':pop(s,e); if ((e=='{' && *p=='}') ||(e=='[' && *p==']') || (e=='(' && *p==')')) p++; else {printf("括号不匹配!");exit(OVERFLOW);} break; default :p++;//其他字符就后移 } } if (StackEmpty(s)) printf("括号匹配成功");

串的模式匹配算法实验报告

竭诚为您提供优质文档/双击可除串的模式匹配算法实验报告 篇一:串的模式匹配算法 串的匹配算法——bruteForce(bF)算法 匹配模式的定义 设有主串s和子串T,子串T的定位就是要在主串s中找到一个与子串T相等的子串。通常把主串s称为目标串,把子串T称为模式串,因此定位也称作模式匹配。模式匹配成功是指在目标串s中找到一个模式串T;不成功则指目标串s中不存在模式串T。bF算法 brute-Force算法简称为bF算法,其基本思路是:从目标串s的第一个字符开始和模式串T中的第一个字符比较,若相等,则继续逐个比较后续的字符;否则从目标串s的第二个字符开始重新与模式串T的第一个字符进行比较。以此类推,若从模式串T的第i个字符开始,每个字符依次和目标串s中的对应字符相等,则匹配成功,该算法返回i;否则,匹配失败,算法返回0。 实现代码如下:

/*返回子串T在主串s中第pos个字符之后的位置。若不存在,则函数返回值为0./*T非空。 intindex(strings,stringT,intpos) { inti=pos;//用于主串s中当前位置下标,若pos不为1则从pos位置开始匹配intj=1;//j用于子串T中当前位置下标值while(i j=1; } if(j>T[0]) returni-T[0]; else return0; } } bF算法的时间复杂度 若n为主串长度,m为子串长度则 最好的情况是:一配就中,只比较了m次。 最坏的情况是:主串前面n-m个位置都部分匹配到子串的最后一位,即这n-m位比较了m次,最后m位也各比较了一次,还要加上m,所以总次数为:(n-m)*m+m=(n-m+1)*m从最好到最坏情况统计总的比较次数,然后取平均,得到一般情况是o(n+m).

括号匹配的检查 课程设计

衡阳师范学院 《C语言数据结构》 课 程 设 计 报 告 题目:括号匹配的检验 班级: 1 1 0 1 学号: 作者姓名: 指导教师: 2012年11月

目录 1设计题目与要求 (3) 1.1实验目的 (3) 1.2问题描述 (3) 1.3设计要求 (3) 2总体设计思想及相关知识 (3) 2.1总体设计思想 (3) 2.2开发环境与工具 (4) 3功能设计 (4) 3.1 抽象数据类型的定义 (4) 3.2 栈的基本运算 (4) 3.3栈的基本操作的实现 (4) 3.4模块流程图 (6) 4源程序代码 (6) 5测试及结果 (9) 6总结 (11) 7小组成员任务分配 (11) 参考文献 (12)

1.设计题目与要求 1.1实验目的 通过对括号匹配的检验的程序设计编写,深入了解和掌握栈的使用,了解栈先进后出的特点,掌握栈的表示和实现。 1.2问题描述 假设表达式中允许包括两种括号:圆括号和方括号,其嵌套的顺序随意,即([]())或[([][])]等为正确的格式,[(])或(()])均为不正确的格式。检验括号是否匹配的方法可用“期待的急迫程度”这个概念来描述。例如考虑下列括号序列:[ ( [ ] [ ] ) ] 1 2 3 4 5 6 7 8 当计算机接受了第一个括号后,它期待着与其匹配的第八个括号的出现,然而等来的却是第二个括号,此时第一个括号只能暂时靠边,而迫切等待与第二个括号相匹配的,第七个括号的出现,类似的,因等来的第三个括号,其期待的匹配程度较第二个括号更急迫,则第二个括号也只能靠边,让位于第三个括号,显然第二个括号的期待急迫性高于第一个括号;在接受了第四个括号后,第三个括号的期待得到满足,消解之后,第二个括号的期待匹配成了当前最急迫的任务了,······,依次类推。可见,这个处理过程恰与栈的特点相吻合。 1.3设计要求 读入圆括号和方括号的任意序列,输出“匹配”或“此串括号匹配不合法”。2.总体设计思想及相关知识 2.1总体设计思想 最内层(最迟出现)的左括号必须与最内层(最早出现)的同类右括号匹配,它最期待着急迫的配对。配对之后,期待得以消除。因此为左括号设置一个栈,置于栈顶的左括号期待配对的急切程度最高。另外,在算法的开始和结束时,栈都应该是空的。例如:[()[]]、 ([{}]) 、{([]]}

括号匹配问题

实验报士 括 号匹配问 题

一、实验目的: 1、熟练掌握数据结构基本知识; 2、通过括号匹配的实验,了解栈的表示和栈的基本操作,掌握栈“后进先出”的特性并能够应用这一特性。 二、实验工具:C-Free 三、实验内容: 设表达式中包含三种括号:圆括号、方括号和花括号,它们可互相嵌套,如 ([( }]) 或({([][ ( ) ] ) } )等均为正确格式,而({[] )、{[()] 或([]} 等均 不正确。在算法中可设置一个栈,每读入一个括号,若是左括号,则直接入栈,等待相匹配的同类右括号;若读入的是右括号,且与当前栈顶的左括号同类型,则二者匹配将栈顶的左括号出栈,否则属于不合法情况。另外,如果输入序列已读完,而栈中仍有等待匹配的左括号,或者读入了一个右括号,而栈中已无等待匹配的同类型的左括号,均属不合法情况。当输入序列和栈同时为空时,说明所有括号完全匹配。 四、实验过程: #include #include #define STACKINCREAMENT 10 #define STACK_INIT_SIZE 100 #define OVERFLOW -2 #define OK 1 #define ERROR 0 typedef int status; typedef char SElemtype; typedef struct { SElemtype *base; SElemtype *top; status stacksize; }sqstack; status Init(sqstack *s) { s->base = (SElemtype *)malloc(STACK_INIT_SIZE * sizeof(SElemtype)); if(!s->base) exit(OVERFLOW); s->top = s->base; s->stacksize = STACK_INIT_SIZE ; return OK; } status push(sqstack *s, SElemtype e) {

正则表达式

[23:39:35] 王尧说:"^\d+$"//非负整数(正整数+ 0) "^[0-9]*[1-9][0-9]*$"//正整数 "^((-\d+)|(0+))$"//非正整数(负整数+ 0) "^-[0-9]*[1-9][0-9]*$"//负整数 "^-?\d+$"//整数 "^\d+(\.\d+)?$"//非负浮点数(正浮点数+ 0) "^(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$"//正浮点数 "^((-\d+(\.\d+)?)|(0+(\.0+)?))$"//非正浮点数(负浮点数+ 0) "^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$"//负浮点数 "^(-?\d+)(\.\d+)?$"//浮点数 "^[A-Za-z]+$"//由26个英文字母组成的字符串 "^[A-Z]+$"//由26个英文字母的大写组成的字符串 "^[a-z]+$"//由26个英文字母的小写组成的字符串 "^[A-Za-z0-9]+$"//由数字和26个英文字母组成的字符串 "^\w+$"//由数字、26个英文字母或者下划线组成的字符串 "^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$"//email地址 "^[a-zA-z]+://(\w+(-\w+)*)(\.(\w+(-\w+)*))*(\?\S*)?$"//url /^(d{2}|d{4})-((0([1-9]{1}))|(1[1|2]))-(([0-2]([1-9]{1}))|(3[0|1]))$/ //年-月-日 /^((0([1-9]{1}))|(1[1|2]))/(([0-2]([1-9]{1}))|(3[0|1]))/(d{2}|d{4})$/ //月/日/年 ^(\w+((-\w+)|(\.\w+))*)\+\w+((-\w+)|(\.\w+))*\@[A-Za-z0-9]+((\.|-)[A-Za-z0-9]+)*\.[A-Za-z0-9]+$ //Emil "(d+-)?(d{4}-?d{7}|d{3}-?d{8}|^d{7,8})(-d+)?" //电话号码 "^(d{1,2}|1dd|2[0-4]d|25[0-5]).(d{1,2}|1dd|2[0-4]d|25[0-5]).(d{1,2}|1dd|2[0-4]d|25[0-5]).(d{1, 2}|1dd|2[0-4]d|25[0-5])$" //IP地址 匹配中文字符的正则表达式:[\u4e00-\u9fa5] 匹配双字节字符(包括汉字在内):[^\x00-\xff] 匹配空行的正则表达式:\n[\s| ]*\r 匹配HTML标记的正则表达式:/<(.*)>.*<\/\1>|<(.*) \/>/ 匹配首尾空格的正则表达式:(^\s*)|(\s*$) 匹配Email地址的正则表达式:^(\w+((-\w+)|(\.\w+))*)\+\w+((-\w+)|(\.\w+))*\@[A-Za-z0-9]+((\.|-)[A-Za-z0-9]+)*\.[A-Za-z0-9]+$ 匹配网址URL的正则表达式:^[a-zA-z]+://(\\w+(-\\w+)*)(\\.(\\w+(-\\w+)*))*(\\?\\S*)?$ 匹配帐号是否合法(字母开头,允许5-16字节,允许字母数字下划线):^[a-zA-Z][a-zA-Z0-9_]{4,15}$ 匹配国内电话号码:(\d{3}-|\d{4}-)?(\d{8}|\d{7})? 匹配腾讯QQ号:^[1-9]*[1-9][0-9]*$ 漢字 Private Ps_KanjiRegex As String = "\u00A0-\u303F\u3200-\u33CF\u4E00-\uFF60\uFFA0-\uFFE5" ''入力可能漢字のコード(正規表現チェック用)

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

括号匹配 实验目的: 使用堆栈的存储结构实现括号匹配,即“(”与“)”必须成对出现、“[”与“]”必须成对出现 实验思路: 1、写出堆栈的相关操作函数,如: 创建【int InitStack( SqStack *S )】、 压入【int Push(SqStack *S,int e)】、 弹出【int Pop(SqStack *S,int *e)】、 销毁【void DestroyStack(SqStack *S)】、 判断是否为空【int StackEmpty(SqStack *S)】等。 2、堆栈的各操作函数完成后编写功能函数——括号匹配函数【int match(char *str)】。 3、括号匹配函数之后编写主函数,使用上述函数实现括号匹配的功能 核心代码: 1、括号匹配函数: int match(char *str){ int i,e; SqStack S; InitStack(&S); for(i=0;;i++){ if(str[i]=='\0')break; if(str[i]=='('||str[i]=='['){ Push(&S,str[i]); }; if(str[i]==')'){ Pop(&S,&e); if(e=='('){ continue; }else{ Push(&S,e); } } if(str[i]==']'){ Pop(&S,&e); if(e=='['){ continue; }else{ Push(&S,e); } }

} if(StackEmpty(&S)){ printf("恭喜您,括号匹配成功,多项式格式合法!\n"); }else{ printf("警告:多项式格式不合法!\n"); } DestroyStack(&S); return 1; } 2、主函数: int main(){ char str[100]; printf("请输入一个表达式:"); scanf("%s",&str); match(str); system("pause"); return 1; } 功能演示: 1、输入:(3+45)*[32-5]/[2-5] 输出:恭喜您,括号匹配成功,多项式格式合法!

串行通信实验报告

串行通信实验报告 班级学号日期 一、实验目的: 1、掌握单片机串行口工作方式的程序设计,及简易三线式通讯的方法。 2、了解实现串行通讯的硬环境、数据格式的协议、数据交换的协议。 3、学习串口通讯的程序编写方法。 二、实验要求 1.单机自发自收实验:实现自发自收。编写相应程序,通过发光二极管观察收发状态。 2.利用单片机串行口,实现两个实验台之间的串行通讯。其中一个实验台作为发送方,另一侧为接收方。 三、实验说明 通讯双方的RXD、TXD信号本应经过电平转换后再行交叉连接,本实验中为减少连线可将电平转换电路略去,而将双方的RXD、TXD直接交叉连接。也可以将本机的TXD接到RXD上。 连线方法:在第一个实验中将一台实验箱的RXD和TXD相连,用P1.0连接发光二极管。波特率定为600,SMOD=0。 在第二个实验中,将两台实验箱的RXD和TXD交叉相连。编写收发程序,一台实验箱作为发送方,另一台作为接收方,编写程序,从内部数据存储器20H~3FH单元中共32个数据,采用方式1串行发送出去,波特率设为600。通过运行程序观察存储单元内数值的变化。 四、程序 甲方发送程序如下: ORG 0000H LJMP MAIN ORG 0023H LJMP COM_INT ORG 1000H MAIN: MOV SP,#53H MOV 78H,#20H

MOV 77H,00H MOV 76H,20H MOV 75H,40H ACALL TRANS HERE: SJMP HERE TRANS: MOV TMOD,#20H MOV TH1,#0F3H MOV TL1,#0F3H MOV PCON,#80H SETB TR1 MOV SCON,#40H MOV IE,#00H CLR F0 MOV SBUF,78H WAIT1: JNB TI,WAIT1 CLR TI MOV SBUF,77H WAIT2: JNB TI,WAIT2 CLR TI MOV SBUF,76H WAIT3: JNB TI,WAIT3 CLR TI

相关文档
最新文档