精华内容
下载资源
问答
  • 括号匹配的检验

    2018-01-13 23:09:33
    通过数据结构的知识进行括号匹配的检验,代码简单易懂
  • 数据结构实验-括号匹配的检验-链栈实现
  • 数据结构与算法(括号匹配的检验括号匹配的检验一、题目二、代码实现三、实例运行总结 括号匹配的检验 一、题目 问题描述: 假设表达式中允许有两种括号:圆括号和方括号,其嵌套的顺序随意,即(()[ ])或...


    括号匹配的检验

    一、题目

    • 问题描述:

    假设表达式中允许有两种括号:圆括号和方括号,其嵌套的顺序随意,即(()[ ])或[([ ] [ ])]等为正确格式,[( ])或(((]均为不正确的格式。检验括号是否匹配的方法可用“期待的紧迫程度”这个概念来描述。例如:考虑下列的括号序列:
    [ ( [ ] [ ] ) ]
    1 2 3 4 5 6 7 8
    当计算机接受了第1个括号以后,他期待着与其匹配的第8个括号的出现,然而等来的却是第2个括号,此时第1个括号“[”只能暂时靠边,而迫切等待与第2个括号相匹配的 第7个括号“)”的出现,类似的,因只等来了第3个括号“[”,此时,其期待的紧迫程度较第2个括号更紧迫,则第2个括号只能靠边,让位于第3个括号,显然第3个括号的期待紧迫程度高于第2个括号,而第2个括号的期待紧迫程度高于第1个括号;在接受了第4个括号之后,第3个括号的期待得到了满足,消解之后,第2个括号的期待匹配就成了最急迫的任务了,…… ,依次类推。可见这个处理过程正好和栈的特点相吻合。

    • 基本要求:
      读入圆括号和方括号的任意序列,输出“匹配”或“此串括号匹配不合法”。

    • 测试数据:
      输入([ ]()),结果“匹配”
      输入 [( )],结果“此串括号匹配不合法”

    • 实现提示:
      设置一个栈,每读入一个括号,若是左括号,则作为一个新的更急迫的期待压入栈中;若是右括号,并且与当前栈顶的左括号相匹配,则将当前栈顶的左括号退出,继续读下一个括号,如果读入的右括号与当前栈顶的左括号不匹配,则属于不合法的情况。在初始和结束时,栈应该是空的。

    • 选作内容
      考虑增加大括号的情况。

    二、代码实现

    代码如下(示例):

    #include "iostream"
    #include "stdlib.h"
    #include "string.h"
    #define MAXSIZE 100
    #define ERROR 0
    #define OK 1
    using namespace std;
    
    typedef int Status;
    typedef struct{
    	char *base;
    	char *top;
    	int stacksize;
    }SqStack;
    Status InitStack(SqStack &S){ //初始化一个顺序栈 
    	S.base = new char[MAXSIZE];
    	if(!S.base) exit(ERROR);
    	S.top = S.base;
    	S.stacksize = MAXSIZE;
    	return OK; 
    }
    Status Push(SqStack &S,char e){ //入栈函数 
    	if(S.top - S.base == S.stacksize) return ERROR;
    	*S.top++ = e;
    	return OK;
    }
    Status Pop(SqStack &S,char &e){ //出栈函数 
    	if(S.top == S.base) return ERROR;
    	e = *--S.top;
    	return OK;
    }
    char GetTop(SqStack S){ //取栈顶元素 
    	if(S.top != S.base) return *(S.top - 1); 
    }
    Status StackEmpty(SqStack S){ //判断顺序栈是否为空 
        if(S.base==S.top){
            return true;
        }
        return false;
    }
    int main(){
    	SqStack S;
    	char str[20],e,c;
    	int t;
    	InitStack(S);
    	cout<<"输入要检验的式子:"; 
    	cin>>str;//输入要检验的式子 
    	t = strlen(str);//得出式子字符串长度(后面循环用) 
    	if(str[0] == ')' || str[0] == ']' || str[0] == '}'){
    		cout<<"此串括号匹配不合法"<<endl; 
    	} //判断第一个字符;(特殊,需要单独判断) 
    	for(int i=1;str[i] !='\0';i++){//判断除第一个字符外的所有字符 
    		e = str[i]; 
    		c = GetTop(S); //取栈顶元素 
    		switch(e){// 选择函数来进行判断,后续操作 
    			case '(':Push(S,e); break;
    			case '[':Push(S,e); break;
    			case '{':Push(S,e); break;
    			case ')':if(c == '(') Pop(S,e);
    			else cout<<"此串括号匹配不合法"<<endl; 
    			break;
    			case ']':if(c == '[') Pop(S,e);
    			else cout<<"此串括号匹配不合法"<<endl; 
    			break;
    			case '}':if(c == '{') Pop(S,e);
    			else cout<<"此串括号匹配不合法"<<endl; 
    			break;
    			default:break; 
    		}
    		if((i+1 == strlen(str)) && StackEmpty(S)) cout<<"此串括号匹配"<<endl;
    		//给匹配结果写条件。 
    	}
    	return 0;
    }
    

    三、实例运行

    输入:()
    结果:
    样例运行
    输入:(2+3)
    结果:
    样例运行
    输入:((]
    结果:
    样理运行

    总结

    这道题,利用了顺序栈来进行解决。将“( [ { ) } ]”等符号通过switch函数选择的方法来进行是否入栈,取栈顶元素的比较,出栈等等…的限定条件来进行结果判断。
    其实利用for函数if函数也能进行实现但是通过最优的解法和代码复杂程度,选择了switch函数。

    展开全文
  • XDOJ 307 括号匹配的检验

    千次阅读 2020-12-16 15:26:27
    XDOJ 307 括号匹配的检验 ***喜欢请点个赞,代码人会超开心的!!!***???????????? 问题描述 假设一个表达式或一段程序中含有三种括号:圆括号“(”和“)”、方括号“[”和“]”、花括号“{”和“}”。试写一个...

    XDOJ 307 括号匹配的检验

    ***喜欢请点个赞,代码人会超开心的!!!***😊🦄🎈

    问题描述

    假设一个表达式或一段程序中含有三种括号:圆括号“(”和“)”、方括号“[”和“]”、花括号“{”和“}”。试写一个程序判别给定的表达式或程序中所含括号是否正确配对出现。

    输入说明

    每行为一个含有括号的表达式或一段程序。

    输出说明

    输出一个right或wrong,表明正确匹配与否。

    输入样例

    while (m<(a[8]+t) {m=m+1; t=t-1;}

    输出样例

    wrong

    解决思路

    • 用栈来解决
    • 遇到左括号入栈,遇到右括号则与栈顶元素相比较看是否匹配,如果不匹配说明可能出现了(({)这种情况,则直接判错flag=0,退出循环;如果匹配则出栈,检验下一个元素。
    • 如果flag=1且栈为空(top=-1)则说明正确配对,输出right

    完整代码

    #include<stdio.h>
    #include<string.h>
    int main()
    {
    	char str[100],stack[100],top;
    	top=-1;//top=-1表示栈为空,入栈top加一然后入栈,出栈top-1
    	gets(str);
        int i,len,flag=1;
    	len=strlen(str);//字符串的长度
    	for(i=0;i<len;i++)
    	{
    		if(str[i]=='('||str[i]=='{'||str[i]=='[')//左括号入栈
    		{
    			top++;
    			stack[top]=str[i];
    		}
    		if(str[i]==')')
    		{
    			if(stack[top]=='(')//右括号匹配
    			 top--;
    			else//右括号不匹配
    			{
    				flag=0;break;
    			}
    		}
    		if(str[i]=='}')
    		{
    			if(stack[top]=='{')
    			 top--;
    			else
    			{
    				flag=0;break;
    			}
    		}
    		if(str[i]==']')
    		{
    			if(stack[top]=='[')
    			 top--;
    			else
    			{
    				flag=0;break;
    			}
    		}	
    	}
    	if(flag==1&&top==-1)//左右括号都匹配且栈空
    		printf("right");
    	else
    		printf("wrong");
    	return 0;
    }
    
    展开全文
  • 利用栈实现括号匹配的检验,存储括号字符的数组通过malloc实现动态分配长度,匹配函数的第一个参数为指向字符的指针(即为存储括号字符的数组的首地址)和一个整数(即为括号字符的总数,为括号个数的2倍),将左...
  • 栈的应用之括号匹配的检验 16年2月29日22:09:16 检验括号匹配的方法,就是对给定的字符串依次检验,若是左括号,入栈,若是右括号,则判断栈最上面那个元素,如果能够匹配,就继续判断,...

    1. 栈的应用之括号匹配的检验
    2. 16年2月29日22:09:16
    3. 检验括号匹配的方法,就是对给定的字符串依次检验,若是左括号,入栈,若是右括号,则判断栈最上面那个元素,如果能够匹配,就继续判断,如果不匹配的话就返回错误。如果是其他字符,就不检验。检验到字符串的结尾的话,这时候要判断栈是否为空,判断是否有剩余的左括号。

    4. #include <stdio.h>
    5. #include <malloc.h>
    6. #include <stdlib.h>

    7. #define STACK_INIT_SIZE 100
    8. #define STACK_INCREMENT 10


    9. typedef struct {
    10.     char *top;
    11.     char *base;
    12.     int stacksize;
    13. }Stack;

    14. char * InitStack(Stack *S)
    15. {
    16.     S->base = (char *)malloc(sizeof(char) * STACK_INIT_SIZE);
    17.     if (!S->base)
    18.     {
    19.         printf("Can not malloc memory for stack.\n");
    20.         exit(-1);
    21.     }

    22.     S->top = S->base;
    23.     S->stacksize = STACK_INIT_SIZE;

    24.     return S->base;
    25. }

    26. void Push(Stack *S, char c)
    27. {
    28.     if ((S->top - S->base) > S->stacksize)
    29.     {
    30.          S->base = (char *)realloc(S->base, (S->stacksize + STACK_INCREMENT));
    31.          if (!S->base)
    32.          {
    33.              printf("Can not reallco memory for Stack.\n");
    34.              exit(-1);    
    35.          }

    36.          S->top = S->base + S->stacksize;
    37.          S->stacksize += STACK_INCREMENT;
    38.     }

    39.     *S->top = c;
    40.     S->top++;
    41. }

    42. int Pop(Stack *S, char c)
    43. {
    44.     if (S->top == S->base)
    45.     {
    46.         printf("The stack is empty.\n");
    47.         exit(-1);
    48.     }

    49.     c = *(--S->top);

    50.     return 1;
    51. }

    52. int IsEmpty(Stack S)
    53. {
    54.     return S.top == S.base ? 1 : 0;
    55. }

    56. char GetTop(Stack S, char *elem)
    57. {
    58.     if (S.top == S.base)
    59.     {
    60.         printf("The Stack is Empty.\n");
    61.         exit(-1);
    62.     }

    63.     *elem = *--S.top;
    64.     return *elem;
    65. }

    66. void TraverseStack(Stack S)
    67. {
    68.     while (S.top > S.base)
    69.     {
    70.         printf("%c", *--S.top);
    71.     }
    72.     printf("\n");
    73. }

    74. int IsMatch(char ch1, char ch2)
    75. {
    76.     if(ch1 == '(' && ch2 == ')')
    77.     {
    78.          return 1;
    79.     }
    80.     else if(ch1 == '[' && ch2 == ']')
    81.     {
    82.         return 1;
    83.     }else if(ch1 == '{' && ch2 == '}')
    84.     {
    85.         return 1;
    86.     }else
    87.     {
    88.         return 0;
    89.     }

    90. }


    91. int main(int argc, char const *argv[])
    92. {
    93.     Stack S;
    94.     char ch[80], *p, e;

    95.     InitStack(&S);

    96.     printf("Please enter the formula with brackets:\n");
    97.     gets(ch);

    98.     p = ch;

    99.     while (*p)
    100.     {
    101.         switch (*p)
    102.         {
    103.             case '(' :
    104.             case '[' :
    105.             case '{' :
    106.             Push(&S, *p);
    107.             break;
    108.             case ')':
    109.             case ']':
    110.             case '}':
    111.             if (IsEmpty(S))
    112.             {
    113.                 printf("Error formula, don't match.\n");    
    114.                 exit(-1);
    115.             }

    116.             if (IsMatch(GetTop(S, &e), *p))
    117.             {
    118.                 Pop(&S, e);
    119.             }
    120.             else
    121.             {
    122.                 printf("Don't match.\n");
    123.                 exit(-1);
    124.             }
    125.             default: ;
    126.         }
    127.         p++;
    128.     }

    129.     if (IsEmpty(S))
    130.     {
    131.         printf("Matched.\n");
    132.     }
    133.     else
    134.     {
    135.         printf("Error, don't match.\n");
    136.     }
    137.     
    138.     return 0;
    139. }

    140. 在写这个程序的时候,程序出错调试了很久,原因是从新写了一个GetTop函数和IsMatch函数,这两个函数写出来以后都没有进行测试就直接使用了,导致的错误。比如刚开始写的IsMatch函数:
    141. int IsMatch(char ch1, char ch2)
    142. {
    143.     if(ch1 == '(' && ch2 == ')')
    144.     {
    145.          return 1;
    146.     }
    147.     else if(ch1 == '[' && ch2 == ']')
    148.     {
    149.         return 1;
    150.     }else if(ch1 == '{' && ch2 == '}')
    151.     {
    152.         return 1;
    153.     }else
    154.     {
    155.         return 0;
    156.     }

    157. }
    158. 它有两个参数,第一个参数是左括号,第二个参数是右括号,但是在下面调用的时候,
    159. IsMatch(*p, GetTop(S, &e)),当程序执行到这里的时候,*p是右括号,而栈里面的元素是左括号,这两个参数写反了,导致了这个函数一直返回0。以后写程序的时候要注意这个问题,所有新写的函数最好都测试一遍,这样花费的时间比最后调试花费的时间少很多。

    <script>window._bd_share_config={"common":{"bdSnsKey":{},"bdText":"","bdMini":"2","bdMiniList":false,"bdPic":"","bdStyle":"0","bdSize":"16"},"share":{}};with(document)0[(getElementsByTagName('head')[0]||body).appendChild(createElement('script')).src='http://bdimg.share.baidu.com/static/api/js/share.js?v=89860593.js?cdnversion='+~(-new Date()/36e5)];</script>
    阅读(117) | 评论(0) | 转发(0) |
    给主人留下些什么吧!~~
    评论热议
    展开全文
  • 栈的应用——括号匹配的检验 //栈的应用——括号匹配的检验 /*算法内容: 以此扫描所有字符,遇到左括号入栈,遇到右括号则弹出栈顶元素检查是否匹配。 匹配失败的情况: 1.左括号单 2.右括号单 3.左右括号不...

    栈的应用——括号匹配的检验

    //栈的应用——括号匹配的检验
    /*算法内容:
    	以此扫描所有字符,遇到左括号入栈,遇到右括号则弹出栈顶元素检查是否匹配。
    	匹配失败的情况:
    	1.左括号单
    	2.右括号单
    	3.左右括号不匹配
    */
     
    #include<stdio.h>
    #include<string.h>
    #define MaxSize 10//定义栈中元素的最大个数 
    typedef struct{
    	char data[MaxSize];//静态数组存放栈中元素
    	int top;//栈顶指针; 
    }SqStack;
    
    //声明需要使用的接口以及函数 
    void InitStack(SqStack &S);
    bool StackEmpty(SqStack S);
    bool Push(SqStack &S,char x);
    bool Pop(SqStack &S,char &x);
     
    //自定义判断是否匹配的检验函数 
    bool bracketCheck(char str[],int length){
    	SqStack S;
    	InitStack(S);//创建一个空栈
    	for(int i=0;i<length;i++){
    		if(str[i]=='(' || str[i]=='[' || str[i]=='{')
    		Push(S,str[i]);//扫描到左括号,入栈
    		else{
    			if(StackEmpty(S))//扫描到右括号,且当前栈为空
    			return false;//匹配失败
    			char topElem;
    			Pop(S,topElem);//栈顶元素出栈
    			if(str[i]==')' && topElem!='(')
    			return false;
    			if(str[i]==']' && topElem!='[')
    			return false;
    			if(str[i]=='}' && topElem!='{')
    			return false;
    		} 
    	} 
    	return StackEmpty(S);//检查完所有括号后,栈空说明匹配成功 
    }
    
    //初始化栈 
    void InitStack(SqStack &S){
    	S.top=-1;//初始化栈顶指针 
    } 
    
    //判断栈空 
    bool StackEmpty(SqStack S){
    	if(S.top==-1)//栈空(栈空的条件:top指针等于-1) 
    	return true;
    	else//栈非空 
    	return false;
    } 
    
    //入栈操作
    bool Push(SqStack &S,char x){
    	if(S.top==MaxSize-1)//栈满,报错
    	return false;
    	S.data[++S.top]=x;//指针top先加1,然后新元素入栈 
    	return true; 
    } 
    
    //出栈操作
    bool Pop(SqStack &S,char &x){
    	if(S.top==-1)//栈空,报错
    	return false;
    	x=S.data[S.top--];//栈顶元素先出栈,指针top再减1
    	return true; 
    } 
    
    //main函数
    int main(){
    	int l;
    	char a[10]={0};
    	gets(a);
    	l=strlen(a);
    	bracketCheck(a,l);
    	if(bracketCheck(a,l))
    	printf("yes");
    	else
    	printf("no");
    	return 0;
    } 
    
    展开全文
  • 1、括号匹配的检验(严蔚敏数据结构49页)
  • 文章目录括号匹配的检验 #include <stdio.h> #include <stdlib.h> #include<iostream> using namespace std; typedef char ElemType; typedef struct StackNode* StackLink; struct ...
  • 利用顺序栈实现括号匹配的检验

    千次阅读 2020-03-20 17:48:51
    利用顺序栈实现括号匹配的检验(严蔚敏版《数据结构》第49页3.2.2) 思路 我的思路是直接入栈和检验同时进行,即:如果两个相近的括号的差值符合要求([ ] 的差值为 2、( ) 的差值为 1),就将此时顺序栈的最上边...
  • 栈的应用实例2—括号匹配的检验 假设表达式中允许包含两种括号:圆括号和方括号,其嵌套的顺序随意。例如:( [ ] ( ) ) 或 [ ( [ ] [ ] ) ] 等为正确的格式;而 [ ( ] )或( ( ) ] ) 等均为不正确的格式。那么...
  • c语言实现括号匹配的检验问题 #include<stdio.h> #define maxsize 8 int match() { int stack[maxsize]; int top=-1; char str[256]; gets(str); int i=0; while(str[i]!=’\0’) { if(str[i]=’(’ || str[i]...
  • 栈应用括号匹配的检验
  • 关于用栈实现括号匹配的检验: 把当前输入的符号与栈顶元素进行比较,若能够配对,则弹出栈顶元素;若无法配对,则当前输入的符号压栈。最后,若栈内元素为空,则表明输出的括号能够一一配对。 #include<iostream...
  • 顺序栈使用——括号匹配的检验

    千次阅读 多人点赞 2017-11-30 16:12:17
    顺序栈使用——括号匹配的检验 码文不易,如果帮助到您,希望您可以帮我刷一下点击量,与您无害,与我有益谢谢 支持原创 。   欢迎大家阅读我的博客,如果有错误请指正,有问题请提问,我会尽我全力改正...
  • 1. 括号匹配的检验 假设表达式中含有3种括号:(),[],{},其嵌套的顺序随意。检验括号是否匹配。 基本思想:在算法中设置一个栈,每读入一个括号,若是右括号,则或者与栈顶匹配的左括号相互消解,或者是不合法的...
  • 17、括号匹配的检验(限2人完成)通过键盘输入一个表达式,其中包含圆括号和方括号(如:()[]),圆括号和方括号时成对出现,其中可以出现嵌套。嵌套形式如([]())或者[([][])]均为正确的格式,而[()或者([()]或者...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 424
精华内容 169
关键字:

括号匹配的检验