精华内容
下载资源
问答
  • "括号匹配正确!!!\n" ); } int main() { char a[] = "(())abc{[(])}" ; char b[] = "(()))abc{[]}" ; char c[] = "(()()abc{[]}" ; char d[] = "(())abc{[]()}" ; MatchBrackets(a); ...

    1.题目:

    a."(())abc{[(])}";
    b."(()))abc{[]}";
    c."(()()abc{[]}";
    d."(())abc{[]()}";
    

    2.整体思路

    这里写图片描述

    以第一个为例:
    这里写图片描述

    3.程序代码

    //Stack.h
    #ifndef __STACK_H__
    #define __STACK_H__
    
    #include <stdio.h>
    #include <Windows.h>
    #include <assert.h>
    
    #define MAXSIZE 10
    //typedef int DataType;
    
    typedef struct StackNode
    {
        DataType arr[MAXSIZE];
        int top;
    }Stack, *pStack;
    
    void InitStack(pStack ps);
    void PushStack(pStack ps, DataType data);
    void PopStack(pStack ps);
    DataType TopStack(pStack ps);
    int SizeStack(pStack ps);
    int EmptyStack(pStack ps);
    
    #endif // __STACK_H__
    
    //Stack.c
    #include "Stack.h"
    
    //初始化栈
    void InitStack(pStack ps)
    {
        assert(ps);
    
        ps->top = 0;
    }
    //压栈
    void PushStack(pStack ps, DataType data)
    {
        assert(ps);
    
        ps->arr[ps->top++] = data;
    }
    //出栈
    void PopStack(pStack ps)
    {
        assert(ps);
    
        ps->top--;
    }
    //求出栈顶的元素
    DataType TopStack(pStack ps)
    {
        assert(ps);
    
        return ps->arr[ps->top - 1];
    }
    //求出栈中元素的个数
    int SizeStack(pStack ps)
    {
        assert(ps);
    
        return ps->top;
    }
    //求栈是否为空
    int EmptyStack(pStack ps)
    {
        assert(ps);
    
        return 0 == ps->top;
    }
    
    //test.c
    #include "Stack.h"
    
    void MatchBrackets(const char *p)
    {
        Stack s;
        InitStack(&s);
    
        while (*p)
        {
            //检测该字符是否为左括号,若果是就压栈
            if (('(' == *p) || ('[' == *p) || ('{' == *p))
            {
                PushStack(&s, *p);
            }//检测该字符是否为右括号
            else if ((')' == *p) || (']' == *p) || ('}' == *p))
            {
                //若此时栈中为空的,说明没有左括号与之匹配,右括号多了
                if (EmptyStack(&s))
                {
                    printf("右括号比左括号多!!\n");
                    return;
                }
                //检测左右括号是否匹配,若匹配则相应的左括号出栈
                if (!(('(' == TopStack(&s) && ')' == *p) ||
                    ('[' == TopStack(&s) && ']' == *p) ||
                    ('{' == TopStack(&s) && '}' == *p)))
                {
                    printf("左右括号不匹配!!!\n");
                    return;
                }
                PopStack(&s);
            }
            p++;
        }
        //结束循环且没有返回,说明检测了所有的字符
        //此时检测栈中是否为空,不为空说明还有多余的左括号
        if (SizeStack(&s) != 0)
        {
            printf("左括号比右括号多!!!\n");
            return;
        }
    
        printf("括号匹配正确!!!\n");
    }
    
    int main()
    {
        char a[] = "(())abc{[(])}";
        char b[] = "(()))abc{[]}";
        char c[] = "(()()abc{[]}";
        char d[] = "(())abc{[]()}";
    
        MatchBrackets(a);
        MatchBrackets(b);
        MatchBrackets(c);
        MatchBrackets(d);
    
        system("pause");
        return 0;
    }

    4.执行结果

    这里写图片描述

    展开全文
  • 利用栈数据结构解决括号匹配问题 题目描述: 在文字处理软件或编译程序设计时,常常需要检查一个字符串或一个 表达式中的括号是否相匹配?利用数据结构的“”机制,设计算法并 编写程序,判断表达式中括号匹配问题...

    利用栈数据结构解决括号匹配问题
    题目描述:
    在文字处理软件或编译程序设计时,常常需要检查一个字符串或一个
    表达式中的括号是否相匹配?利用数据结构的“栈”机制,设计算法并
    编写程序,判断表达式中括号匹配问题。(了解“栈” 的定义)
    题目描述:输入算术表达式 A,以#键结束。其中包括:整数、四则运
    算符,和六种括号“(”, “)”, “[”, “]” , “{”, “}”,请你利
    用数据结构的“栈”机制设计算法并编写程序,检查算术表达式 A 的
    括号是否匹配,如果匹配输出“括号匹配成功”,否则输出“括号匹配
    失败”。
    样例 1: 8*(3+3)/5*[9-3]+9#
    输出:括号匹配成功
    样例 2: 8*(9-6)/5*[3+3*{9-5}]#
    输出:括号匹配成功
    样例 2: 8*(9-6)/5][3+3{9-5}#
    输出:括号匹配失败

    源程序编码如下:
    #include
    #include
    using namespace std;

    int main()
    {string s;
    int n=0;
    while ( cin>>s[n]&&s[n]!= ‘#’)
    {
    n++;
    }

    stack<char> brackets;
    int i=0;
    for(i=0;i<s.length();i++)
     {      if(s[i]=='('||s[i]=='['||s[i]=='{')
               brackets.push(s[i]);
            if(s[i]==')')
            {if(brackets.empty()){
                    cout<<"NO!"<<endl;
                return 0;}
                if(brackets.top()=='(')
            brackets.pop();
                else {cout<<"NO!"<<endl;
                return 0;}
            }
            if(s[i]==']')
            {if(brackets.empty()){
                    cout<<"NO!"<<endl;
                return 0;}
                if(brackets.top()=='[')
            brackets.pop();
                else {cout<<"NO!"<<endl;
                return 0;}
            }
            if(s[i]=='}')
            {if(brackets.empty()){
                    cout<<"NO!"<<endl;
                return 0;}
                if(brackets.top()=='{')
            brackets.pop();
                else {cout<<"NO!"<<endl;
                return 0;}
            }
    }
    if(!brackets.empty()) cout<<"NO!"<<endl;
    else cout<<"Yes!"<<endl;
    return 0;
    

    }

    使用说明:
    输入任意算术表达式,检验其中的括号是否匹配,中括号套在大括号外面也算正确。#之后的表达式不再检查。

    重点:
    1.了解栈的用法;
    定义栈:
    #include
    stack a;
    出栈 a.pop()
    入栈 a.push()
    返回栈顶元素 a.top()
    返回栈是否为空 a.empty()

    展开全文
  • 数据结构作业 实现 括号匹配 问题

    数据结构作业  栈  实现 括号匹配 问题

    毕竟太菜 照着demo敲了几天才 搞定。

    栈的几个基本应用函数顺便敲了  其他的就不详说了.

    见代码:

    #include <stdio.h>
    #include <stdlib.h>
    
    #define OK      1
    #define ERROR   0
    #define TRUE    1
    #define FALSE   0
    #define OVERFLOW -1
    #define STACK_INIT_SIZE 100
    #define STACKINCREMENT 10
    #define BUFFERSIZE 200
    
    typedef int Status; //函数返回状态
    typedef char SElemType;  //栈元素类型
    typedef struct{//栈结构定义
        SElemType *base;
        SElemType *top;
        int stacksize;
    }SqStack;
    
    Status InitStack(SqStack *S)
    {
        //构造一个空栈S
        S->base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
        if(!S->base)//分配失败
        {
            printf("分配内存失败.\n");
            return 0;
        }
        S->top=S->base;
        S->stacksize=STACK_INIT_SIZE;
        return OK;
    }
    
    Status DestroyStack(SqStack *S)
    {
        //销毁栈S,S不再存在
        if(!S)//S为空
        {
            printf("指针为空,释放失败.\n");
            exit(0);
        }
        free(S);
        return OK;
    }
    
    Status ClearStack(SqStack *S)
    {
        //把栈S置为空栈
        if(!S)//S不存在
            return FALSE;
        S->top=S->base;//直接将栈顶指针指向栈底
        return OK;
    }
    
    Status StackEmpty(SqStack S)
    {
        //若栈S为空栈,则返回TRUE,否则返回FALSE
        if(S.top==S.base)
            return TRUE;
        else
            return FALSE;
    }
    
    int StackLength(SqStack S)
    {
        //返回S元素的个数,即栈的长度
        return S.stacksize;
    }
    
    Status GetTop(SqStack S,SElemType *e)
    {
        //若栈不为空,则用e返回S的栈顶元素,并返回OK;否则返回FALSE
        if(S.top==S.base)
        {
            return FALSE;
        }
        else
        {
            *e=*(S.top-1);
            return OK;
        }
    }
    
    Status Push(SqStack *S,SElemType e)
    {
        //插入元素e为新的栈顶元素
        if(S->top-S->base>=S->stacksize)//栈已满,追加存储空间
        {
            S->base=(SElemType *)realloc(S->base,(S->stacksize+STACKINCREMENT)*sizeof(SElemType));
            if(!S->base)
            {
                printf("重新申请空间失败.\n");
                exit(0);
            }
            S->top=S->base+S->stacksize;//更改栈顶指针
            S->stacksize+=STACKINCREMENT;
        }
        *S->top++=e;
        return OK;
    }
    
    Status Pop(SqStack *S,SElemType *e)
    {
        //若栈S不为空,则删除S的栈顶元素,用e返回其值,并返回OK,否则返回ERROR
        if(S->top==S->base)//栈为空
        {
            printf("栈为空.\n");
            return ERROR;
        }
        *e=*(--S->top);
        return OK;
    }
    
    Status StackTraverse(const SqStack *S){
        //从栈底到栈顶依次对每个元素进行访问
        SElemType *p=S->base;
        if(S->base==S->top)
        {
            printf("栈为空.\n");
            return FALSE;
        }
        while(p!=S->top)
        {
            printf("%c",*p++);
        }
        printf("\n");
        return OK;
    }
    
    Status BracketMatch(SqStack *S,const char *string){
        //输入字符串string中的括号匹配,返回TRUE;否则返回FALSE
        const char *p=string;
        SElemType e;
        InitStack(S);
        while(*p!='\0')//遍历字符串
        {
            switch(*p)//判断p的值
            {
                case '('://左括号,入栈
                case '[':
                case '{':
                    Push(S,*p);
                    break;
                case ')':
                    if(FALSE==GetTop(*S,&e))
                        return FALSE;
                    if(e=='(')
                    {
                        if(ERROR==Pop(S,&e))
                            return FALSE;
                    }
                    else
                        return FALSE;
                    break;
                case ']':
                    if(FALSE==GetTop(*S,&e))
                        return FALSE;
                    if(e=='[')
                    {
                        if(ERROR==Pop(S,&e))
                            return FALSE;
                    }
                    else
                        return FALSE;
                    break;
                case '}':
                    if(FALSE==GetTop(*S,&e))
                        return FALSE;
                    if(e=='{')
                    {
                        if(ERROR==Pop(S,&e))
                            return FALSE;
                    }
                    else
                        return FALSE;
                    break;
                default:  ;
            }
            p++;
        }
        if(!StackEmpty(*S)) //字符串遍历完,栈非空,不匹配
            return FALSE;
        return TRUE;
    }
    
    
    int main()
    {
        char *String;
        SqStack stack;
        String=(char*)malloc(sizeof(char)*BUFFERSIZE);
        if(!String)
        {
            printf("分配内存失败.\n");
            return 0;
        }
        while(1)
        {
            printf("请输入一行含括号的表达式(输入\"!\"退出):");
            gets(String);
            if(String[0]=='!')//退出
                break;
            if(TRUE==BracketMatch(&stack,String))
            {
                printf("\n能正确匹配.\n\n");
            }
            else
            {
                printf("\n不能正确匹配.\n\n");
            }
        }
        return 0;
    }
    


    展开全文
  • 运用的知识当输入的字符串扫瞄时遇到左括号就进栈,右括号就弹。最后查看括号是否匹配
  • 问题引入;表达式中每一个左括号都会和一个右括号相匹配,不然就会报错; 当读一串表达式例如(a+b)*c+(d-p) 利用存储特点(先进后出,这里更... 若空则括号匹配 #include<iostream> using namespace std;

    问题引入;表达式中每一个左括号都会和一个右括号相匹配,不然就会报错;
    当读一串表达式例如(a+b)*c+(d-p)
    利用栈存储特点(先进后出)在对上面表达式进行读取的时候,有以下步骤

    读取时:
    1)遇到左括号``就入栈
    2)遇到右括号``且栈非空就从栈中弹出一个左括号``与其匹配
       若栈空则右括号')'多
    全部读取完:
    3)对栈进行判断若非空则左括号'('多
      若栈空则括号匹配
    

    在这里插入图片描述

    #include<iostream>
    using namespace std;
    class Matcher{
    public:
         Matcher(string str);
        ~Matcher();
        int Match();
    private:
         string str;
      };
    Matcher::Matcher(string str){
    this->str=str;} //构造函数
    Matcher::~Matcher(){};
    int Matcher::Match(){
    	char s[10];       //定义顺序栈
    	int i,top=-1;
    	for(i=0;str[i]!='\0';i++)
    	{
    	   if(str[i]==')')
    	   {
    	      if(top>-1) top--;
    	      else return -1;//如果栈空
    	    }
    	else if(str[i]=='(')
    	    s[++top]=str[i];
    	}
    	if(top==-1) return 0;
    	else return 1;
    }
    int main()
    {string str;
    cout<<"输入表达式"<<endl;
    cin >> str;
    Matcher m(str);
    int k=m.Match();
    if(k==0)cout << "括号匹配" << endl;
    else if(k==1)cout << "左括号多" << endl;
    else cout << "右括号多" << endl;}
    

    在这里插入图片描述
    (2020/10/17)

    展开全文
  • 数据结构实验之四:括号匹配 Time Limit: 1000MS Memory Limit: 65536KB Submit Statistic Problem Description  给你一串字符,不超过50个字符,可能包括括号、数字、字母、标点符号、空格,你的任务是检查...
  • /*括号匹配问题*/ public class Stack_Test_2 { public static void main(String[] args) { String str = "()()(长安(上海))"; boolean match = isMath(str); System.out.println(str+"中的括号匹配与否:"+match...
  • 问题描述 任意给定一个字符串,字符串中包含除了空格、...如果字符串中的括号匹配,则输出数字 1,并且在下一行输出{}、[]、()相对应的匹配个数,否则输出数字 0。 示例 输入: &()dgn*[{%}12] 输出: 1 ...
  • 括号匹配 给定一个字符串,其中的字符只包含三种括号:花括号{ }、中括号[ ]、圆括号( ),即它仅由 “( ) [ ] { }” 这六个字符组成。设计算法,判断该字符串是否有效,即字符串中括号是否匹配。括号匹配要求括号...
  • 本文实例讲述了基于PHP实现栈数据结构括号匹配算法。分享给大家供大家参考,具体如下: ,体现的是后进先出,即LIFO。队列,体现的是先进先出,即FIFO。 操作: array_pop() //尾出 array_push() //尾进 或 ...
  • C语言--数据结构 实现括号匹配问题

    千次阅读 多人点赞 2020-03-26 16:36:06
    基本特点:“后进先出”,好比子弹上膛,最后放入弹夹中的子弹最先被射出,正因为有此特性,可以解决许多实际问题,例如即将讨论的括号匹配问题。 多说不易,来张图唤醒一下。 子弹上膛示意图 的特性类似于...
  • 所以可以用数据结构中的顺序来解决这个问题 。在此我就以小括号匹配为例来说明。在匹配检查时,我们建立一个空的顺序。我们从左到右依次的进行检查,当遇到的是左括号'('时,就让其进栈。当遇到')'时在将其...
  • 的应用括号匹配问题:原理:代码实现: 括号匹配问题: 原理: 1、括号匹配成功的情况:为空 2、括号匹配失败的情况:  a、下一个为右括号但是和栈顶左括号不匹配  b、下一个是右括号但以空  c、所有的...
  • 利用顺序的操作函数 typedef char SElemType; #include"Stack.h" int kuohaopipei() { char p; SqStack s; char temp; InitStack(s); p=getchar(); while(p!='\n') { if(p=='('||p=='['||p=='{') Push(s,...
  • 利用顺序解决括号匹配问题(c++)-- 数据结构
  • 数据结构括号匹配问题 要求大、中、小括号两两匹配,基本思路可以通过来实现。这里我使用的是简单的静态顺序,大小固定,同时定义了栈顶指针top。程序包含了的几个最基本的操作,初始化、判空、压入、弹出,...
  • //匹配括号空 char TopElem ; Pop ( S , TopElem ) ; //出栈顶元素且赋予TopElem if ( str [ i ] == '(' && TopElem != ')' ) return false ; if ( str [ i ] ...
  • // 括号匹配问题 InitStack ( &S) : 的初始化 DestoryStack(&S) : 销毁S Push ( &S, e) :进栈 Pop (&S ) : 出栈 GetTop (S ): 取栈顶元素 IsEmpty (S): 判空否 ***/ #include #include #define STACK_MAX 1
  • 括号匹配问题,首先有一个待匹配的字符串(一串括号)和一个(后进先出),一直判断是否有待匹配括号(有左压入栈,有右就匹配): 一:有。判断是否为空: (一)空。匹配失败。 (二)非空。 ---------判断待...
  • 相信大家对这个名词都是有一些了解的。但是具体什么是呢?的作用?我们先来看一下百度百科给的解释: (stack)又名堆栈,它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被...

空空如也

空空如也

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

数据结构栈括号匹配问题

数据结构 订阅