精华内容
下载资源
问答
  • c语言括号匹配算法
    2021-05-22 12:36:25

    #include

    #include

    #define STACK_INIT_SIZE 100

    #define STACKINCREMENT 10

    #define OVERFLOW -2

    #define INFEASIBLE -1

    #define ERROR 0

    #define OK 1

    typedef char SElemType;

    typedef struct

    {

    SElemType *base;

    SElemType *top;

    int stacksize;

    }SqStack;

    int InitStack(SqStack* sq)

    {

    sq->base=(SElemType*)malloc(STACK_INIT_SIZE*sizeof(SElemType));

    if(!sq->base)exit(OVERFLOW);

    sq->top=sq->base;

    sq->stacksize=STACK_INIT_SIZE;

    return OK;

    }

    int GetTop(SqStack* sq,SElemType* e)

    {

    if(sq->base==sq->top)return ERROR;

    *e=*(sq->top-1);

    return OK;

    } //GetTop

    int Push(SqStack* sq,SElemType e)

    {

    if(sq->top-sq->base>=sq->stacksize)

    {

    sq->base=(SElemType*)realloc(sq->base,(sq->stacksize+STACKINCREMENT)*sizeof(SElemType));

    if(!sq->base)exit(OVERFLOW);

    sq->top=sq->base+sq->stacksize;

    sq->stacksize+=STACKINCREMENT;

    }

    *sq->top++=e;

    return OK;

    }//Push

    int Pop(SqStack* sq,SElemType* e)

    {

    if(sq->base==sq->top)return ERROR;

    *e=*--sq->top;

    return OK;

    }//Pop

    int Clear(SqStack* sq,SElemType e)

    {

    sq->top=sq->base;

    return OK;

    }//Clear

    int StackEmpty(SqStack* sq)

    {

    if(sq->base==sq->top)return OK;

    else return ERROR;

    }//StackEmpty

    int Match(SElemType ch,SElemType str)

    {

    if(ch=='('&&str==')')return OK;

    else if(ch=='['&&str==']')return OK;

    else if(ch=='{'&&str=='}')return OK;

    else return ERROR;

    }

    void BracketMatch(SElemType *str)

    {

    SqStack S;

    int i;

    char ch;

    InitStack(&S);

    for(i=0;str[i]!='#';i++)

    {

    switch(str[i])

    {

    case '(':

    case '[':

    case '{':

    Push(&S,str[i]);

    break;

    case ')':

    case ']':

    case '}':

    if(StackEmpty(&S))

    {

    printf("/n右括号多余!/n");return;

    }

    else

    {

    GetTop(&S,&ch);

    if(Match(ch,str[i]))Pop(&S,&ch);

    else

    {

    printf("/n左右括号不匹配!/n");return;

    }

    }//else

    }//switch

    }//for

    if(StackEmpty(&S))

    printf("/n匹配成功!/n");

    else

    printf("/n左括号多余!/n");

    }//BracketMatch

    void main(){//输入以'#'结束 int i; char ch; char str[100]; gets(str); BracketMatch(&str[0]);}

    更多相关内容
  • C语言括号匹配

    千次阅读 2020-05-16 16:10:02
    给定一串字符,不超过100个字符,可能包括括号、数字、字母、标点符号、空格,编程检查这一串字符中的( ) ,[ ],{ }是否匹配。 输入格式: 输入在一行中给出一行字符串,不超过100个字符,可能包括括号、数字、字母、...

    给定一串字符,不超过100个字符,可能包括括号、数字、字母、标点符号、空格,编程检查这一串字符中的( ) ,[ ],{ }是否匹配。

    输入格式:
    输入在一行中给出一行字符串,不超过100个字符,可能包括括号、数字、字母、标点符号、空格。

    输出格式:
    如果括号配对,输出yes,否则输出no。

    输入样例1:
    sin(10+20)
    输出样例1:
    yes
    输入样例2:
    {[}]
    输出样例2:
    no

    思路:题目输入一些字符串,我们就先保留括号之类的,判断是否匹配。如果遇到左括号,就入栈,如果遇到一个右括号,就与栈顶元素比较,如果匹配,出栈,就继续重复操作,直到字符串没有了。期间一旦出现不匹配的括号对就直接输出no ,如果栈空了,说明匹配了,就输出yes。

    #include<stdio.h>
    #include<string.h>
    
    int left(char c)//判断是否为左括号,是返回1,否返回0.
    {
        if(c=='('||c=='{'||c=='[')
        {
            return 1;
        }
        else
        {
            return 0;
        }
    }
    
    int right(char c)//判断是否为右括号,是返回1,否返回0.
    {
        if(c==')'||c=='}'||c==']')
        {
            return 1;
        }
        else
        {
            return 0;
        }
    }
    
    int check(char left,char right)//判断是否左右括号匹配,是返回1,否返回0.
    {
        if(left=='('&&right==')')
        {
            return 1;
        }
        
        if(left=='{'&&right=='}')
        {
            return 1;
        }
        
        if(left=='['&&right==']')
        {
            return 1;
        }
        
        return 0;
    }
    
    int main()//主函数。
    {
        int i=0,l;//定义循环变量i和字符串长度l。
        char stack[200];//定义字符数组存放左括号。
        int top=0;//初始化栈,栈为空,栈顶top=0;
        char s[200];//存放字符串。
        gets(s);//输入字符串到s数组中,数组中除了存放了有字符串,末尾还存放了“/0”,以表示是字符串。
        l=strlen(s);//字符串长度。
        
        for(i=0;i<l;i++)//遍历每个字符串中的字符。
        {
            if(left(s[i])==1)//如果是左括号入栈,同时栈顶向上移动。
            {
                stack[top]=s[i];
                top++;
            }
            else if(right(s[i])==1)//如果是右括号,那么开始在栈中判断是否匹配。
            {
                if(check(stack[top-1],s[i]))//如果匹配,那么栈顶下移,继续执行下一次新的for循环。
                {
                    top--;
                    continue;
                }
                else//如果不匹配,那么输出no,程序返回0,结束。
                {
                    printf("no");
                    return 0;
                }
            }
        }
        //如果不是在for循环中结束,那么就需要判断栈是否为空。因为不是在for循环中结束,说明都匹配成功了,但会出现特殊情况比如((()),令栈不为空。所以是否括号匹配成功不仅要判断是否右括号都有左括号使其匹配,还需要判断栈是否为空。
        if(top==0)
        {
          printf("yes");
          return 0;
        }
        else
        {
        printf("no");
        return 0;
        }
       
    }
    
    展开全文
  • 括号匹配C语言

    2018-12-05 20:55:34
    3利用栈的操作实现括号匹配的检验。 .括号匹配算法思想 (1)出现的凡是“左括号”,则进栈; (2)出现的是“右括号”, 首先检查栈是否空? 若栈空,则表明该“右括号”多余 否则和栈顶元素比较? 若相...
  • C语言括号匹配问题

    万次阅读 2019-03-06 15:27:10
    功能:可进行括号匹配,输入可包括{}, [], (), 其他任意字符 输入示例: 3 {{{{{{{[[[[[1314]]]]]}}}}}}} {{{{{[[[(())]}}}}} ((({{{{{[[521]]}}}}}))) 输出示例: Yes No Yes Auth...

    主要思路:

    1. 主要是借助栈对括号进行匹配,遍历整个字符串,若为左括号,则入栈;若为右括号,则判断栈是否为空,以及栈顶元素与当前元素是否匹配;
    2. 要特别注意每个字符串的遍历结束的条件。
    /*-------------------------------------------------------
    功能:可进行括号匹配,输入可包括{}, [], (), 其他任意字符
    输入示例:
    3
    {{{{{{{[[[[[1314]]]]]}}}}}}}
    {{{{{[[[(())]}}}}}
    ((({{{{{[[521]]}}}}})))
    输出示例:
    Yes
    No
    Yes
    Author: Zhang Kaizhou
    Date:2019-3-6 14:59:06
    --------------------------------------------------------*/
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #define MAXSIZE 1000
    
    typedef struct node{ // 定义一个结点数据类型用于存放每行结果
        char res[10];
        struct node * pnext;
    } Node;
    
    typedef struct{ // 定义一个栈数据类型,用于符号判断
        char oper[MAXSIZE];
        int top;
    } OperStack;
    
    void judge_blanket_match(char * str, Node * p);
    void push_oper(OperStack * p_oper, char ch);
    void pop_oper(OperStack * p_oper, char * ch);
    void list_tail_insert(Node ** pphead, Node ** pptail, Node * p);
    void list_print(Node * phead);
    
    int main(){
        int n, i;
        char str[MAXSIZE] = { '\0' };
        Node * phead = NULL, * ptail = NULL;
        scanf("%d", &n);
        for(i = 0; i < n; i++){ // 循环输入n组测试数据
            scanf("%s", str);
            Node * pnew = (Node *)calloc(1, sizeof(Node)); // 产生一个结点用于存储结果
            judge_blanket_match(str, pnew);
            list_tail_insert(&phead, &ptail, pnew);
        }
        list_print(phead);
    
        free(phead);
        free(ptail);
        return 0;
    }
    
    void judge_blanket_match(char * str, Node * p){
        OperStack * p_oper = (OperStack *)calloc(1, sizeof(OperStack)); // 定义一个栈指针
        p_oper->top = -1; // 初始化栈顶指针
        int flag = 0;
        char temp;
        while(* str != '\0'){ // 遍历整个字符串
            switch(* str){
            case '{':
            case '[':
            case '(':
                push_oper(p_oper, * str); // 左括号直接入栈
                str++;
                break;
            case '}':
                if(p_oper->top >= 0 && p_oper->oper[p_oper->top] == '{'){ // 右括号时,若栈非空,判断与栈顶元素是否匹配
                    pop_oper(p_oper, &temp); // 若匹配,则出栈栈顶元素
                    str++;
                    break;
                }else{ // 不匹配,则结果为No,终止循环
                    strcpy(p->res, "No");
                    flag = 1;
                    * str = '\0'; // 终止遍历
                    break;
                }
            case ']':
                if(p_oper->top >= 0 && p_oper->oper[p_oper->top] == '['){
                    pop_oper(p_oper, &temp);
                    str++;
                    break;
                }else{
                    strcpy(p->res, "No");
                    flag = 1;
                    * str = '\0';
                    break;
                }
            case ')':
                if(p_oper->top >= 0 && p_oper->oper[p_oper->top] == '('){
                    pop_oper(p_oper, &temp);
                    str++;
                    break;
                }else{
                    strcpy(p->res, "No");
                    flag = 1;
                    * str = '\0';
                    break;
                }
            default:
                str++;
                break;
            }
        }
        if(flag == 0 && p_oper->top < 0){
            strcpy(p->res, "Yes");
        }else{
            strcpy(p->res, "No");
        }
        free(p_oper); // 释放操作数栈
        p_oper = NULL; // 原指针置空
        return;
    }
    
    void push_oper(OperStack * p_oper, char ch){
        if(p_oper->top == MAXSIZE - 1){
            printf("The operator stack is full!\n");
        }else{
            p_oper->top++;
            p_oper->oper[p_oper->top] = ch;
        }
        return;
    }
    
    void pop_oper(OperStack * p_oper, char * ch){
        if(p_oper->top < 0){
            printf("The operator stack is empty!\n");
        }else{
            * ch = p_oper->oper[p_oper->top];
            p_oper->top--;
        }
        return;
    }
    
    void list_tail_insert(Node ** pphead, Node ** pptail, Node * p){
        if(* pphead == NULL){
            * pphead = p;
            * pptail = p;
        }else{
            (*pptail)->pnext = p;
            * pptail = p;
        }
        return;
    }
    
    void list_print(Node * phead){
        while(phead != NULL){
            puts(phead->res);
            phead = phead->pnext;
        }
        return;
    }
    
    展开全文
  • C语言括号匹配问题 用C语言实现括号匹配算法。要求输入任意的包含括号的字符序列(不一定是表达式),都能判断是否匹配。在测试时,要求序列中既有括号,也要有普通字符,括号必须包含( )、[ ]、{ }这三种。 数组栈 ...

    C语言括号匹配问题

    用C语言实现括号匹配算法。要求输入任意的包含括号的字符序列(不一定是表达式),都能判断是否匹配。在测试时,要求序列中既有括号,也要有普通字符,括号必须包含( )、[ ]、{ }这三种。

    数组栈

    代码

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    #define MAX_SIZE 50
    
    typedef char datatype;
    
    datatype stack[MAX_SIZE];
    
    int top = 0, base = 0;
    
    void initial() //初始化
    {
        top = base = 0;
    }
    
    void push(datatype x) //进栈
    {
        stack[top] = x;
    }
    
    void pop() //出栈
    {
        top--;
    }
    
    char top_data() //栈顶元素
    {
        return stack[top];
    }
    
    int main()
    {
        initial();
        datatype str[MAX_SIZE] = {'\0'};
        gets(str);
        char ch[MAX_SIZE] = {'\0'};
        strcpy(ch, str);
    
        int flag = 1;
        for (int i = 0; ch[i] != '\0'; i++)
        {
            if ((ch[i] == '{') || (ch[i] == '[') || (ch[i] == '('))
            {
                push(ch[i]);
            }
            else if ((ch[i] == '}') || (ch[i] == ']') || (ch[i] == ')'))
            {
                char a;
                a = top_data();
                pop();
                if ((a == '{' && ch[i] == '}') || (a == '(' && ch[i] == ')') || (a == '[' && ch[i] == ']'))
                {
                    continue;
                }
                else
                    flag = 0;
            }
        }
    
        if (top != 0)
        {
            flag = 0;
        }
    
        if (flag == 0)
        {
            printf("FAUSE\n");
        }
        else
            printf("TRUE\n");
        return 0;
    }
    

    示例1:
    输入: “()”
    输出:TRUE

    示例2:
    输入: “()[]{}”
    输出:TRUE

    示例3:
    输入: “(]”
    输出:FAUSE

    示例4:
    输入: “{[]}”
    输出:TRUE

    展开全文
  • 2、假设一个算术表达式中可以包含三种括号:园括号“(”和“)”、方括号“[”和“]”、花括号“{”和“}”,且这三种括号可按任意的次序嵌套使用。编写判别给定表达式中所含括号是否正确配对出现的算法(已知表达式...
  • C语言实现括号匹配

    2021-11-22 20:56:45
    学过数据结构的同学应该很清楚,这个用栈这种数据结构就很容易达到目的,当然其他方式也行,这里我主要介绍使用栈完成括号匹配的方法 /*以下为Bracket1函数,可以处理三种括号匹配,请补充完整程序*/ int Bracket1...
  • c语言括号匹配问题的一种解法。
  • 题目描述现在,有一行括号序列,里面只包含”(“,”)”,”[“,”]”四种符号,请你检查这行括号是否配对。 如: []是匹配的 ([])[]是匹配的 ((]是不匹配的 ([)]是不匹配的 求解思想这里提供了两种求解方法:一...
  • C语言实现表达式括号匹配算法及程序
  • C语言括号匹配问题解决方法,给定一个输入的字符串,包含括号(和),能够找出(和)的个数,并指出(或者)不正确的位置。
  • c语言实现括号匹配检测

    千次阅读 2019-11-10 15:00:37
    c语言实现括号匹配检测 #include<stdio.h> #include<iostream> #include<string> typedef struct bracketStack { char data; bracketStack* next; int quenesize; //初始化函数 void ...
  • 详细解释括号匹配算法,并用C语言实现
  • /*括号匹配算法*/#include#define FALSE 0#define TRUE 1#define MAXSIZE 100typedef char DataType;//定义栈typedef struct stack{DataType data[MAXSIZE];int top;}SeqStack;//初始化栈void InitStack(SeqStack *s...
  • 问题标题数据结构C语言括号的检验源程序 , 数据结构(C) 请用类C语言实现括号匹配的检验这个算法2019-8-21来自ip:13.149.196.77的网友咨询浏览量:270手机版问题补充:数据结构C语言括号的检验源程序 , 数据结构(C) 请...
  • 1要求编写程序检查该字符串...2分析用一个栈,就能解决该问题,左括号栈顶字符必须和第一个入栈的右括号字符匹配。 栈介绍:栈是一种特殊的线性表,仅能在线性表的一端操作。 栈的特性:后进先出(LIFO) 由于正在学数...
  • 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]...
  • C语言括号匹配算法

    2021-09-17 10:58:42
    1、C语言括号匹配算法 一起加油兄弟姐妹们!!!冲冲冲 /** * 思想很简单就是左括号进栈,遇到右括号的时候,就把栈顶元素取出,然后匹配,然后对结果进行不用的处理 * 括号匹配算法: * 匹配失败的可能: ...
  • C语言验证括号匹配

    2018-03-30 18:07:27
    c语言下,利用栈的结构,判断一个表达式的括号是否合法
  • 请写一个程序,判断给定表达式中的括号是否匹配,既左右括号顺序和数量都匹配。 输入说明 输入为一个表达式字符串,长度不超过50。 输出说明 对输入的表达式,若其中的括号匹配的,则输出“yes”,否则输出“no...
  • 我们在编写程序的时候经常会遇到括号不匹配而导致语法错误的问题,现在我们可以通过栈来自己实现括号匹配的问题,了解其实现细节。 我们假设在表达式中只有()[]这两种括号,其嵌套的方式是随意的。检验括号是否匹配...
  • } } } } if(isEmpty(&s)) { printf("\n括号匹配"); } else printf("\n左括号多余"); } int main(){ char str[100], enter,ch; seqstack s; initStack(&s); printf("请输入字符串:\n"); scanf("%s",str); scanf("%c...
  • 括号匹配C语言实现

    千次阅读 2021-04-02 10:49:13
    若你掌握以下知识,你可以更好地理解此...括号匹配有点像俄罗斯方块,或者消消乐,怎么说呢,我给大家用图演示一个过程就知道了 1.首先准备一个数组装要匹配的括号们,再准备一个栈。 2.然后把数组内第一个括号丢入栈
  • C语言实现栈的括号匹配

    千次阅读 2021-04-22 18:15:50
    二、方便起见,这里我们使用栈的顺序存储结构来存储待匹配的元素: 因为存储的是括号,所以数据部分是char类型。 我们开辟了10个连续的char型空间存储元素,1个Int型空间存储指针,指针的值为数组下标。 #include<...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 42,694
精华内容 17,077
关键字:

c语言括号匹配

友情链接: en.stsw-stm32088.zip