编写一程序检查C源程序文件中{}、()等括号是否匹配,并输出检测到的不匹配的括号及所对应括号与所在的行号

最新推荐文章于 2024-04-14 00:41:44 发布
最新推荐文章于 2024-04-14 00:41:44 发布
阅读量631 收藏 2
点赞数 1
分类专栏： 括号匹配 栈 c 文章标签： c语言 vscode windows 开发语言 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77630091/article/details/132172408
版权
c 同时被 3 个专栏收录
5 篇文章 0 订阅
订阅专栏
栈
2 篇文章 0 订阅
订阅专栏
括号匹配
1 篇文章 0 订阅
订阅专栏

前言

括号匹配问题算是栈应用中比较经典的问题了，在数据结构的书中还有各种考试中会出现。最近刷题的时候也遇到了，就想写一篇文章整理一下。

代码

方法一：这里我使用了两个栈进行括号匹配的核心算法

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
 
#define STACK 20
#define STACKINCREMENT 10
static int line_number = 1,i=0,j=0;
typedef struct
{
    char *base;         // 栈底指针
    char *top;          // 栈顶指针
    int stackSize;      // 栈大小
    int a[1000];
} sqStack;
 
void InitStack(sqStack *s)
{
    s->base = (char *)malloc(STACK * sizeof(char));  // 为栈分配内存
    if (!s->base)
        exit(0);  // 分配失败则退出程序
    s->top = s->base;
    s->stackSize = STACK;
}
 
void Push(sqStack *s, char e)
{
    if (s->top - s->base >= s->stackSize)
    {
        s->base = (char *)realloc(s->base, (s->stackSize + STACKINCREMENT) * sizeof(char));  // 栈满时重新分配内存
       // if (!s->base)
         //   exit(0);
        s->top = s->base + s->stackSize;
        s->stackSize = s->stackSize + STACKINCREMENT;
    }
    *(s->top) = e;   // 将元素压入栈顶
    s->top++;
}
 
int Pop(sqStack *s, char *e)
{
    if (s->top == s->base)
        return 1;  // 栈空，出栈失败
    *e = *--(s->top);  // 弹出栈顶元素
    return 0;
}
int match(char e, char c)  
{
    if( e=='(' && c==')' )
        return 1;
    return 0;
}
int match1(char e, char c)  
{
    if( e=='{' && c=='}' )
        return 1;
    return 0;
}
int StackLen(sqStack s)
{
    return (s.top - s.base);  // 返回栈长度
}
 
int main()
{
    sqStack s,ss;
    char c, e;
    InitStack(&s);
    InitStack(&ss);
    printf("Please enter the name of the file: ");
    char filename[100];
    scanf("%s", filename);
 
    FILE *file = fopen(filename, "r");
    if (!file)
    {
        printf("File not found or cannot be opened.\n");
        return 1;  // 无法打开文件，程序退出
    }
	int n = 0;
    while ((c = fgetc(file)) != EOF)
    {
        if(c=='/'){
            c=fgetc(file);
            if(c=='*'){
            do{c = fgetc(file);}while(c!='*');
            }
        }
        if (c == '\n')
        {
            line_number++;  // 更新行号
            continue;
        }
 
        if( c=='(' || c==')' )
        {                        // 如果是括号，就进栈
            if( !StackLen(s) )   //如果栈的长度为空，c直接进栈
            {
                Push(&s, c);     //存入c  
            }
            else                   //如果c放入时，栈已经不空了，
            {
                Pop(&s, &e);
                     //取出栈顶元素来判断与新放入的c是否匹配
                if( !match(e, c) )
                    //如果match执行结果为假，即不匹配
                {
                    Push(&s, e);
                    //原栈顶元素重新入栈
                    Push(&s, c);
                    s.a[i++]=line_number;
                    //将输入的括号字符入栈
                }
              else if(match(e,c))
                {
                    i--;
                }
            }
        }
     else if( c=='{' || c=='}' )
        {                        // 如果是括号，就进栈
            if( !StackLen(ss) )   //如果栈的长度为空，c直接进栈
            {
                Push(&ss, c);     //存入c  
            }
            else                   //如果c放入时，栈已经不空了，
            {
                Pop(&ss, &e);
                     //取出栈顶元素来判断与新放入的c是否匹配
                if( !match1(e, c) )
                    //如果match执行结果为假，即不匹配
                {
                    Push(&ss, e);
                    //原栈顶元素重新入栈
                    Push(&ss, c);
                    ss.a[j++]=line_number;
                    //将输入的括号字符入栈
                }
                else if(match1(e,c))
                {
                    j--;
                }
            }
        }
    }
    fclose(file);
 	for(Pop(&s, &e),i=i-1;e;Pop(&s, &e),i--)
   	 {
    	  printf("Unmatched %c at end of file in line %d\n", e, s.a[i]);  // 输出未匹配的括号错误
    	  n++;
          strcpy(&e,"\0");
   	 }
    for (Pop(&ss, &e),j=j-1;e;Pop(&ss, &e),j--)
   	 {
    	  printf("Unmatched %c at end of file in line %d\n", e, ss.a[j]);  // 输出未匹配的括号错误
    	  n++;
          strcpy(&e,"\0");
   	 }
	if (n == 0)
    {
        printf("All parentheses in the input file match exactly.\n");  // 输出所有括号匹配正确
    }
    else
    {
        printf("There are unmatched parentheses in the input file.\n");  // 输出存在未匹配括号的错误
    }
    return 0;
}

 方法二：适合简单方面的括号匹配（易看懂）

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define STACK 20
#define STACKINCREMENT  10
typedef struct
{
    char *base;//栈底   
    char *top; //栈顶    
    int stackSize;
}sqStack;
InitStack(sqStack *s)    
{
    s->base = (char *)malloc(STACK * sizeof(char));
    if( !s->base )       
        exit(0);         
    s->top = s->base;    
    s->stackSize = STACK;
}                       
Push(sqStack *s, char e)              
{
    if( s->top - s->base >= s->stackSize )
    {                                     
        s->base = (char *)realloc(s->base, (s->stackSize + STACKINCREMENT) * sizeof(char));
        if( !s->base )                  
            exit(0);                    
        s->top = s->base + s->stackSize; 
        s->stackSize = s->stackSize + STACKINCREMENT;
    }
    *(s->top) = e;     
    s->top++;          
}
Pop(sqStack *s, char *e)    
{
    if( s->top == s->base )     
        return 1;             
    *e = *--(s->top);         
}
int StackLen(sqStack s)      
{
    return (s.top - s.base); //返回长度：顶-底
}
int match(char e, char c)  
{
    if( e=='(' && c==')' )
        return 1;
    if( e=='{' && c=='}' )
        return 1;
    return 0;
}
int main()                       
{
    sqStack s;//栈
    char c, e;                
    InitStack( &s );//初始化
    printf("Please enter the program：");
    scanf("%c", &c);             
    while( c !='@')
    {
        if( c=='(' || c==')' || c=='{' || c=='}' )
        {                        // 如果是括号，就进栈
            if( !StackLen(s) )   //如果栈的长度为空，c直接进栈
            {
                Push(&s, c);     //存入c
            }
            else                   //如果c放入时，栈已经不空了，
            {
                Pop(&s, &e);
                     //取出栈顶元素来判断与新放入的c是否匹配
                if( !match(e, c) )
                    //如果match执行结果为假，即不匹配
                {
                    Push(&s, e);
                    //原栈顶元素重新入栈
                    Push(&s, c);
                    //将输入的括号字符入栈
                }
            }
        }
        scanf("%c", &c);
    }
    if( !StackLen(s) )
    {
        printf("\nThe parentheses in the input string match exactly \n");
    }
    else
    {
        char p;
        Pop(&s, &p);
        char q;
        if(p=='{'){strcpy(&q,"}");}
        if(p=='}'){strcpy(&q,"{");}
          if(p=='('){strcpy(&q,")");}
         if(p==')'){strcpy(&q,"(");}
        printf("\nThe parentheses in the input string do not exactly match is lack:%c\n",q);
        char w,y;   
        for(Pop(&s, &w);w;Pop(&s, &w)){
          if(w=='{'){strcpy(&y,"}");}
         if(w=='}'){strcpy(&y,"{");}
          if(w=='('){strcpy(&y,")");}
         if(w==')'){strcpy(&y,"(");}
            printf("and:%c\n",y);
            strcpy(&w,"\0");
        }
    }
    return 0;
}

方法三：方法一的简易版但不完整

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define STACK 20
#define STACKINCREMENT 10

typedef struct
{
    char *base;         // 栈底指针
    char *top;          // 栈顶指针
    int stackSize;      // 栈大小
} sqStack;

void InitStack(sqStack *s)
{
    s->base = (char *)malloc(STACK * sizeof(char));  // 为栈分配内存
    if (!s->base)
        exit(0);  // 分配失败则退出程序
    s->top = s->base;
    s->stackSize = STACK;
}

void Push(sqStack *s, char e)
{
    if (s->top - s->base >= s->stackSize)
    {
        s->base = (char *)realloc(s->base, (s->stackSize + STACKINCREMENT) * sizeof(char));  // 栈满时重新分配内存
        if (!s->base)
            exit(0);
        s->top = s->base + s->stackSize;
        s->stackSize = s->stackSize + STACKINCREMENT;
    }
    *(s->top) = e;   // 将元素压入栈顶
    s->top++;
}

int Pop(sqStack *s, char *e)
{
    if (s->top == s->base)
        return 1;  // 栈空，出栈失败
    *e = *--(s->top);  // 弹出栈顶元素
    return 0;
}
int match(char e, char c)  
{
    if( e=='(' && c==')' )
        return 1;
    if( e=='{' && c=='}' )
        return 1;
    return 0;
}
int StackLen(sqStack s)
{
    return (s.top - s.base);  // 返回栈长度
}

int main()
{
    sqStack s;
    char c, e;
    InitStack(&s);
    printf("Please enter the name of the file: ");
    char filename[100];
    scanf("%s", filename);

    FILE *file = fopen(filename, "r");
    if (!file)
    {
        printf("File not found or cannot be opened.\n");
        return 1;  // 无法打开文件，程序退出
    }
	int n = 0;
    int line_number = 1;
    while ((c = fgetc(file)) != EOF)
    {
        if (c == '\n')
        {
            line_number++;  // 更新行号
            continue;
        }

        if( c=='(' || c==')' || c=='{' || c=='}' )
        {                        // 如果是括号，就进栈
            if( !StackLen(s) )   //如果栈的长度为空，c直接进栈
            {
                Push(&s, c);     //存入c
            }
            else                   //如果c放入时，栈已经不空了，
            {
                Pop(&s, &e);
                     //取出栈顶元素来判断与新放入的c是否匹配
                if( !match(e, c) )
                    //如果match执行结果为假，即不匹配
                {
                    Push(&s, e);
                    //原栈顶元素重新入栈
                    Push(&s, c);
                    //将输入的括号字符入栈
                }
            }
        }
    }
    fclose(file);
 	while (Pop(&s, &e)== 0)
   	 {
    	  printf("Unmatched %c at end of file in line %d\n", e, line_number);  // 输出未匹配的括号错误
    	  n++;
   	 }
	if (n == 0)
    {
        printf("All parentheses in the input file match exactly.\n");  // 输出所有括号匹配正确
    }
    else
    {
        printf("There are unmatched parentheses in the input file.\n");  // 输出存在未匹配括号的错误
    }
    return 0;
}

方法四：双栈进行套用

#include <stdio.h>
#include <stdlib.h>

#define MAX_SIZE 100

typedef struct {
char bracket;
int line;
} BracketInfo;

typedef struct {
BracketInfo data[MAX_SIZE];
int top;
} Stack;

void initializeStack(Stack *s) {
s->top = -1;
}

int isEmpty(Stack *s) {
return s->top == -1;
}

void push(Stack *s, char bracket, int line) {
if (s->top == MAX_SIZE - 1) {
printf("Stack overflow\n");
exit(1);
}
s->top++;
s->data[s->top].bracket = bracket;
s->data[s->top].line = line;
}

BracketInfo pop(Stack *s) {
if (isEmpty(s)) {
BracketInfo emptyInfo = {'\0', -1};
return emptyInfo;
}
BracketInfo popped = s->data[s->top];
s->top--;
return popped;
}

int main() {
 char filename[100];
    scanf("%s", filename);
 
    FILE *file = fopen(filename, "r");
    if (!file)
    {
        printf("File not found or cannot be opened.\n");
        return 1;  // 无法打开文件，程序退出
    }

Stack s;
initializeStack(&s);

char lineBuffer[1000];
int lineNum = 0;

while (fgets(lineBuffer, sizeof(lineBuffer), file)) {
lineNum++;

for (int i = 0; lineBuffer[i] != '\0'; i++) {
    if (lineBuffer[i] == '(' || lineBuffer[i] == '{') {
    push(&s, lineBuffer[i], lineNum);
    } 
    else if (lineBuffer[i] == ')'  || lineBuffer[i] == '}') {
    if (isEmpty(&s)) {
   // printf("Unmatched %c at line %d\n", lineBuffer[i], lineNum);
    } else {
    BracketInfo popped = pop(&s);
    if ((popped.bracket == '(' && lineBuffer[i] != ')') ||(popped.bracket == '{' && lineBuffer[i] != '}')) {
    //printf("Mismatched %c at line %d, should be %c\n", lineBuffer[i], lineNum, popped.bracket);
                }
            }
        }
    }
}

while (!isEmpty(&s)) {
BracketInfo popped = pop(&s);
printf("Unmatched %c at line %d\n", popped.bracket, popped.line);
}

fclose(file);
return 0;
}

 方法五：适合相邻括号进行匹配

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define STACK 20
#define STACKINCREMENT 10
int line_number = 1,i=0;
typedef struct
{
    char *base;         // 栈底指针
    char *top;          // 栈顶指针
    int stackSize;      // 栈大小
    int a[10000];
} sqStack;

void InitStack(sqStack *s)
{
    s->base = (char *)malloc(STACK * sizeof(char));  // 为栈分配内存
    if (!s->base)
        exit(0);  // 分配失败则退出程序
    s->top = s->base;
    s->stackSize = STACK;
}

void Push(sqStack *s, char e)
{
    if (s->top - s->base >= s->stackSize)
    {
        s->base = (char *)realloc(s->base, (s->stackSize + STACKINCREMENT) * sizeof(char));  // 栈满时重新分配内存
        if (!s->base)
            exit(0);
        s->top = s->base + s->stackSize;
        s->stackSize = s->stackSize + STACKINCREMENT;
    }
    *(s->top) = e;   // 将元素压入栈顶
    s->top++;
}

int Pop(sqStack *s, char *e)
{
    if (s->top == s->base)
        return 1;  // 栈空，出栈失败
    *e = *--(s->top);  // 弹出栈顶元素
    return 0;
}
int match(char e, char c)  
{
    if( e=='(' && c==')' )
        return 1;
    if( e=='{' && c=='}' )
        return 1;
    return 0;
}
int StackLen(sqStack s)
{
    return (s.top - s.base);  // 返回栈长度
}

int main()
{
    sqStack s;
    char c, e;
    InitStack(&s);
    printf("Please enter the name of the file: ");
    char filename[100];
    scanf("%s", filename);

    FILE *file = fopen(filename, "r");
    if (!file)
    {
        printf("File not found or cannot be opened.\n");
        return 1;  // 无法打开文件，程序退出
    }
	int n = 0;
    while ((c = fgetc(file)) != EOF)
    {
        if(c=='/'){
            c=fgetc(file);
            if(c=='*'){
            do{c = fgetc(file);}while(c!='*');
            }
        }
        if (c == '\n')
        {
            line_number++;  // 更新行号
            continue;
        }

        if( c=='(' || c==')' || c=='{' || c=='}' )
        {                        // 如果是括号，就进栈
            if( !StackLen(s) )   //如果栈的长度为空，c直接进栈
            {
                Push(&s, c); 
                s.a[i++]=line_number;    //存入c  
            }
            else                   //如果c放入时，栈已经不空了，
            {
                Pop(&s, &e);
              
                     //取出栈顶元素来判断与新放入的c是否匹配
                if( !match(e, c) )
                    //如果match执行结果为假，即不匹配
                {
                    Push(&s, e);
                    //原栈顶元素重新入栈
                    Push(&s, c);
                     s.a[i++]=line_number;
                    //将输入的括号字符入栈
                } 
                if(match(e,c)) 
                {
                    i--;
                }  
            }
        }
    }
    fclose(file);
 	for (Pop(&s, &e),i=i-1;e;Pop(&s, &e),i--)
   	 {
    	  printf("Unmatched %c at end of file in line %d\n", e, s.a[i]);  // 输出未匹配的括号错误
    	  n++;
          strcpy(&e,"\0");
   	 }
	if (n == 0)
    {
        printf("All parentheses in the input file match exactly.\n");  // 输出所有括号匹配正确
    }
    else
    {
        printf("There are unmatched parentheses in the input file.\n");  // 输出存在未匹配括号的错误
    }
    return 0;
}

方法六： 底层代码不全可以查看思路

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define STACK 20
#define STACKINCREMENT 10
int line_number = 1,i=0,j=0;
typedef struct
{
    char *base;         // 栈底指针
    char *top;          // 栈顶指针
    int stackSize;      // 栈大小
    int a[10000];
} sqStack;

void InitStack(sqStack *s)
{
    s->base = (char *)malloc(STACK * sizeof(char));  // 为栈分配内存
    if (!s->base)
        exit(0);  // 分配失败则退出程序
    s->top = s->base;
    s->stackSize = STACK;
}

void Push(sqStack *s, char e)
{
    if (s->top - s->base >= s->stackSize)
    {
        s->base = (char *)realloc(s->base, (s->stackSize + STACKINCREMENT) * sizeof(char));  // 栈满时重新分配内存
        if (!s->base)
            exit(0);
        s->top = s->base + s->stackSize;
        s->stackSize = s->stackSize + STACKINCREMENT;
    }
    *(s->top) = e;   // 将元素压入栈顶
    s->top++;
}

int Pop(sqStack *s, char *e)
{
    if (s->top == s->base)
        return 1;  // 栈空，出栈失败
    *e = *--(s->top);  // 弹出栈顶元素
    return 0;
}
int match(char e, char c)  
{
    if( e=='(' && c==')' )
        return 1;
    if( e=='{' && c=='}' )
        return 1;
    return 0;
}
int StackLen(sqStack s)
{
    return (s.top - s.base);  // 返回栈长度
}

int main()
{
    sqStack s;
    sqStack w;
    char c, e;
    InitStack(&s);
    InitStack(&w);
    printf("Please enter the name of the file: ");
    char filename[100];
    scanf("%s", filename);

    FILE *file = fopen(filename, "r");
    if (!file)
    {
        printf("File not found or cannot be opened.\n");
        return 1;  // 无法打开文件，程序退出
    }
	int n = 0;
    while ((c = fgetc(file)) != EOF)
    {
        if(c=='/'){
            c=fgetc(file);
            if(c=='*'){
            do{c = fgetc(file);}while(c!='*');
            }
        }
        if (c == '\n')
        {
            line_number++;  // 更新行号
            continue;
        }

        if( c=='(' || c==')' )
        {                        // 如果是括号，就进栈
            if( !StackLen(s) )   //如果栈的长度为空，c直接进栈
            {
                Push(&s, c); 
                s.a[i++]=line_number;    //存入c  
            }
            else                   //如果c放入时，栈已经不空了，
            {
                Pop(&s, &e);
              
                     //取出栈顶元素来判断与新放入的c是否匹配
                if( !match(e, c) )
                    //如果match执行结果为假，即不匹配
                {
                    Push(&s, e);
                    //原栈顶元素重新入栈
                    Push(&s, c);
                     s.a[i++]=line_number;
                    //将输入的括号字符入栈
                } 
                if(match(e,c)) 
                {
                    i--;
                }  
            }
        }
        if( c=='{' || c=='}' )
        {                        // 如果是括号，就进栈
            if( !StackLen(w) )   //如果栈的长度为空，c直接进栈
            {
                Push(&w, c); 
                w.a[j++]=line_number;    //存入c  
            }
            else                   //如果c放入时，栈已经不空了，
            {
                Pop(&w, &e);
              
                     //取出栈顶元素来判断与新放入的c是否匹配
                if( !match(e, c) )
                    //如果match执行结果为假，即不匹配
                {
                    Push(&w, e);
                    //原栈顶元素重新入栈
                    Push(&w, c);
                     w.a[j++]=line_number;
                    //将输入的括号字符入栈
                } 
                if(match(e,c)) 
                {
                    j--;
                }  
            }
        }
    }
    fclose(file);
 	for (Pop(&s, &e),i=i-1;e;Pop(&s, &e),i--)
   	 {
    	  printf("Unmatched %c at end of file in line %d\n", e, s.a[i]);  // 输出未匹配的括号错误
    	  n++;
          strcpy(&e,"\0");
   	 }
        for (Pop(&w, &e),j=j-1;e;Pop(&w, &e),j--)
   	 {
    	  printf("Unmatched %c at end of file in line %d\n", e, w.a[j]);  // 输出未匹配的括号错误
    	  n++;
          strcpy(&e,"\0");
   	 }
	if (n == 0)
    {
        printf("All parentheses in the input file match exactly.\n");  // 输出所有括号匹配正确
    }
    else
    {
        printf("There are unmatched parentheses in the input file.\n");  // 输出存在未匹配括号的错误
    }
    return 0;
}

运行结果 ：封面

江里看花
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
专栏目录
c程序括号匹配检查.c
09-29
使用C语言实现括号匹配检查，对输入的一段文字进行排查，如果前置括号或者后置括号不存在，则指出改正，对于c语言入门的同学能够巩固所学知识，获得提升。
15. 检查括号是否匹配
jin_xinyu的博客
12-02 1271
【问题描述】 编写一个程序，用于对C源程序进行括号匹配检查，并将检查结果输出到文件中。 程序应检查输入源程序中左右大括号、小括号的个数是否相等,并且符合C语言语法规定的括号嵌套规则，不得交叉嵌套。输入文件最长不超过500个字符。 本程序只检查括号是否匹配，不用对输入源程序中的其它语法成份进行检查。 【输入文件】 输入文件为当前目录下的check.in，是一段任意的C程序。 【输出文件】 输出文件为当前目录下的check.out。该文件只有一行，是一个单词"True"或"False"。如果没有括号匹配错误则输
【自用】【数据结构习题 练1】括号匹配判定
最新发布
consvain的博客
04-14 1052
str_bracket 记录有效bracket序列以便最终配对成功时候输出。n_line记录行，行与括号一同存入stack以便配对失败时候查找行号。
C程序括号匹配检查（带详细注释）
热门推荐
weixin_40500026的博客
06-21 1万+
编写一程序检查C源程序文件中{}、()等括号是否匹配,并输出第一个检测到的不匹配的括号及所对应括号所在的行号（程序中只有一个括号不匹配）。注意：1.     除了括号可能不匹配外，输入的C源程序无其它语法错误；2.     字符常量、字符串常量及注释中括号不应被处理，注释包括单行注释//和多行/* */注释3. 字符和字符串常量中不包含特殊的转义字符（\',\"）5. 程序中出现有意义括号的个数不...
BUAA_C程序括号匹配检查
weixin_45927469的博客
06-28 3586
【问题描述】 编写一程序检查C源程序文件中{}、()等括号是否匹配,并输出第一个检测到的不匹配的括号及所对应括号所在的行号（程序中只有一个括号不匹配）。 注意： 1.除了括号可能不匹配外，输入的C源程序无其它语法错误。 2.字符常量、字符串常量及注释中括号不应被处理，注释包括单行注释//和多行/* */注释 3.字符常量和字符串常量中不包含转义字符’和"； 4.程序中出现有意义括号的个数不超过200个； 不匹配判断规则： 1.当检测的程序括号为’{‘时，若其前序尚未匹配的括号为’(‘时，输出该’('左括号及
C语言 检查括号是否匹配
qq_41740162的博客
04-25 4987
文章目录原理括号不匹配情型中间不匹配型后面多余型 原理 我们有这样一组括号序列 根据下面的序号我们可以知道第一个括号与最后一个括号进行匹配,第二个与倒数第二个进行匹配其他的以此类推,我们发现括号匹配具有先进后匹配的特性,这一特性刚好和栈的特性相匹配(先进后出),我们利用栈的原理进行存储 当我们遇到(,[,{这一类的括号使我们让这一类括号进栈,当我们遇到),],}这一类括号使我不让他们入栈反而让栈...
括号匹配程序,非常完善
07-11
可直接运行，且判断结果不会出错，我从网上下载的一段代码，然后根据自己的理解修改而成，非常完善。
括号匹配程序c源码.zip
11-18
【标题】"括号匹配程序c源码.zip" 提供的是一个使用C语言编写的用于处理括号匹配问题的源代码。在计算机科学中，括号匹配是一个基础但至关重要的概念，尤其在解析表达式、编译器设计、文本编辑器和编程语言解释器等...
c++括号匹配算法.zip
10-29
C++括号匹配算法是计算机科学中一个基础且重要的问题，主要涉及到字符串处理和递归思想。在编程语言中，括号（如圆括号、方括号、花括号等）用于定义代码块或者表达式的结构，正确匹配的括号是程序语法正确性的关键...
括号匹配括号匹配括号匹配
11-18
在编程领域，括号匹配是一项基础且至关重要的概念，尤其在C语言及其衍生的C++等编程语言中。括号匹配涉及到程序语法的正确性，是编译器或解释器在解析代码时需要解决的关键问题之一。这个话题通常与解析器、编译原理...
括号的匹配检验
ONE OF LIST
11-04 847
//只是一个括号匹配检验的程序，假设只有（和【两种。 #include "stdafx.h" #include #include #include #include using namespace std; int _tmain(int argc, _TCHAR* argv[]) { cout<<"输入一个字符串:"<<endl; string str; cin>>str
数据结构-检查C文件符号匹配-C语言-【检查C源文件中{}、()等括号是否匹配,（包含引号注释） 并输出第一个检测到的不匹配的括号及所对应括号所在的行号（程序中只有一个括号不匹配）。】
qq_37746855的博客
04-19 1334
检查C文件符号匹配题目描述【样例输入1】【样例输入2】【样例输入3】题目分析实现思路（详细见代码）代码实现 题目描述 【样例输入1】 若当前目录下输入文件example.c中内容如下： #include<stdio.h> int main(){ printf("{ hello world }\n"); // } ) without maching ')' at line 4 【样例输入2】 若当前目录下输入文件example.c中内容如下： #include<stdio.h&gt
【数据结构 C描述】设计一个程序用于检测输入的符号是否匹配，如果不匹配则输出提示并退出。
AlanLee97的博客
10-20 2663
这里使用链栈的方式实现。 //main.cpp #include &amp;amp;lt;iostream&amp;amp;gt; #include &amp;amp;lt;malloc.h&amp;amp;gt; #include &amp;amp;lt;stdlib.h&amp;amp;gt; #include &amp;quot;LinkStack.h&amp;quot; using namespace std; int
C源程序括号匹配检查（C语言）
Running Snail
12-04 3899
【问题描述】 编写程序，检查给定的C源程序文件中花括号是否匹配，规定花括号的总个数不超过50个。花括号匹配规则： 1)文件中左花括号“{”个数与右花括号“}”个数相等； 2)从文件中头开始顺序查找右花括号“}”的个数，在任何时候均不超过所遇到的左花括号“{”个数。 注意： 1)源程序注释中（/* … */）花括号应被忽略，不参与匹配。 2)源程序中的字符串常量不会出现花括号。 【输入形式】 要检查...
北航第四次作业——C程序括号匹配检查
m0_74019378的博客
04-03 292
北航第四次作业——C程序括号匹配检查
BUAA数据结构第四次作业2023
weixin_50567399的博客
04-21 4600
BUAA数据结构第四次上机作业
C语言括号匹配检测
for_lani的博客
12-01 1153
由于比较简单，不需要栈实现，只需要记录三种左括号的状态，然后依次匹配加减即可。
c语言程序:编写一程序,检测任意表达式中的括号是否配对.,试用C语言设计一个程序,程序的功能是接收任意输入一个算术表达式,判断表达式中的括号是否配对出现....
weixin_32742203的博客
05-21 1234
//最近的栈作业~#includeusingnamespacestd;classStack{private:intmaxSize;inttop;int*p;public:Stack(intsize){maxSize=size;top=-1;p=newint[maxSize];}~Stack(){delete[]p;}voidClear()...
python编写一个程序，用于对C源程序进行括号匹配检查，并将检查结果输出到文件中。 程序应检查输入源程序中左右大括号、小括号的个数是否相等,并且符合C语言语法规定的括号嵌套规则，不得交叉嵌套。输入文件最长不超过500个字符。
05-25
以下是一个简单的 Python 程序，用于对输入的 C 源程序进行括号匹配检查，并将结果输出到文件中： ```python def check_parentheses(file_in, file_out): with open(file_in, 'r') as f_in, open(file_out, 'w') as f_out: code = f_in.read().strip() stack = [] error = False for i, char in enumerate(code): if char in '({[': stack.append((char, i)) elif char in ')}]': if not stack: f_out.write(f"Error: Extra closing bracket at position {i}\n") error = True else: last_bracket, pos = stack.pop() if (last_bracket == '(' and char != ')') or (last_bracket == '{' and char != '}') or (last_bracket == '[' and char != ']'): f_out.write(f"Error: Mismatched brackets at positions {pos} and {i}\n") error = True if not error and stack: f_out.write("Error: Extra opening bracket(s) at positions ") for bracket, pos in stack: f_out.write(f"{pos}, ") f_out.write("\n") elif not error: f_out.write("All brackets are matched and nested correctly.\n") check_parentheses('input.c', 'output.txt') ``` 这个程序首先打开输入文件，读取其中的代码。然后，使用一个栈来跟踪打开的括号，当遇到一个左括号时，将其压入栈中；当遇到一个右括号时，将其弹出栈，并检查它是否与栈顶的左括号匹配。如果有任何错误，则将错误信息写入输出文件并将错误标志设置为 True。最后，如果没有错误，但栈中仍然有未配对的左括号，则将这些括号视为错误，并将其位置写入输出文件。 注意，这个程序只检查了括号的匹配和嵌套，而没有检查其他语法错误。如果需要完整的 C 语言语法分析器，请使用专业的工具。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值