devbox
Monodyee
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

数据结构练习题之栈与队列：括号匹配问题（C语言实现）_括号匹配问题 栈c语言

作者：Monodyee | 2024-05-20 16:44:55

赞

踩

括号匹配问题 栈c语言

     这只是其中一个例题，看完我对这道题的分析之后，关于括号匹配的问题你肯定能够掌握个差不多。转载请注明本文链接！

目录

一、问题描述

二、问题分析 

三、代码实现

（一）、定义结构体

（二）、初始化栈

（三）、进栈函数

（四）、判断栈是否为空

（五）、出栈函数

（六）、获取栈顶元素

（七）、主函数

（八）、运行结果

 四、完整代码

一、问题描述

Description

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

Input

 输入数据有多组，处理到文件结束。

Output

 如果匹配就输出“yes”，不匹配输出“no”

Sample

Input （输入）

sin(20+10)
{[}]

Output（输出）

yes
no

二、问题分析 

       这是一道让我做了三天才做出来的题，只能说我太**，把简单的问题想的过于复杂了。那我们来分析一下括号匹配问题我们需要做什么，我们需要注意什么。

（1）、首先看到括号匹配问题，我们需要一个栈，这个栈是用来存储算术表达式中的左括号'('，'{'，'['的。

（2）、在存储左括号时，我们需要判断一下栈是否已满，只要栈不满我们就可以把它直接压入到栈中。

（3）、当我们遇到右括号时，我们需要看一下当前栈中是否有元素，如果栈是空的，那么我们就不用判断下去了，直接结束程序，括号是不匹配的；如果栈中有元素，那我们我们就拿出来栈顶元素，与当前我们遇到的右括号进行匹配，如果他们是一对，那么我们就把当前栈中的左括号出栈，继续扫描算术表达式，循环执行第（2）个步骤和第（3）个步骤；如果不是一对，那么我们也不用继续下去了，直接结束程序，括号是不匹配的。

（4）、我们要知道括号是成对出现的，有左括号无右括号，有右括号无左括号，这都是不行的。需要注意的是：当我们判断括号是否匹配时，不能把栈顶的括号和当前的右括号是否相等作为判断条件。因为左括号和右括号肯定是不相等的。我们只能判断一下当前右括号是哪一种括号，然后我们手动的定义出它对应的左括号，用这个我们定义的左括号和栈顶括号进行是否相等的判断。

（5）、对于这道题来说，当我们遇到'\0'时才停止扫描，之所以是‘\0'，是因为数组存储完毕后，系统会自动的在末尾加上'\0'用来标记数组存储到这里就结束了。否则一直扫描算数表达式中的括号。

（6）、扫描完算术表达式之后，我们要看一下当前栈中是否还有元素，如果没有元素了，说明括号匹配，如果栈中还有元素，说明不匹配。因为我们遇到匹配的括号就执行出栈操作，全部匹配的话，到最后栈中的元素应该是都栈了的。

三、代码实现

（一）、定义结构体

       根据我们对栈的了解，我们要先定义一个结构体，这个结构体中有一个数组用于存储元素，还有一个栈顶标记位top。因为栈是后进先出的。我们只需要一个栈顶标记位就可以对这个栈进行进栈出栈判空等的操作。如果对栈的只是不够熟悉，请先看完有关栈的知识再接着往下看。

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #define Maxsize 100   //数组大小
  4. typedef struct ST
  5. {
  6.     char data[Maxsize]; //存储栈中的元素
  7.     int  top;           //栈顶标记位
  8. }Stack;                 //用Stack来表示这个结构体

（二）、初始化栈

       因为数组的下标是从0开始的，刚开始我们并没有存元素，那我们让top==-1即可。当存入元素的时候，让top+1，然后在它标记的位置存储元素即可。

  1. void Init(Stack *L)
  2. {
  3.     L->top=-1;
  4. }

（三）、进栈函数

  1. void Push(Stack *L,char x)
  2. {
  3.     if(L->top>=Maxsize)     //当我们栈满的时候就不能存储元素了
  4.     {
  5.         return;
  6.     }
  7.     L->top++;               //让top先加一
  8.     L->data[L->top]=x;       //在top标记的位置存储当前的元素x
  9. }

（四）、判断栈是否为空

  1. int Empty(Stack L)
  2. {
  3.     if(L.top==-1)
  4.     {
  5.         return 1;//为空返回1
  6.     }
  7.     return 0;    //不为空返回0
  8. }

（五）、出栈函数

        出栈的时候只需判断栈是否为空，如果不为空，那就让栈顶标记位top-1即可。

  1. void Pop(Stack *L)
  2. {
  3.     if(L->top==-1)
  4.     {
  5.         return;
  6.     }
  7.     L->top--;
  8. }

（六）、获取栈顶元素

       当我们遇到右括号的时候，我们就需要获取栈顶的元素了，来判断栈顶元素是否和当前右括号匹配。

  1. char Get(Stack L)
  2. {
  3.     return L.data[L.top];
  4. }

（七）、主函数

         我们上面定义的函数都很简单，主要是看我们在主函数中如何去调用上面这些函数，在什么情况下我们才能用到上面的函数。

  1. int main()
  2. {
  3.     Stack L;                                       //定义一个栈
  4.     char s[100];                                   //定义一个字符数组用来存储我们输入的算术表达式
  5.     while(gets(s))                                  //用来获得我们输入的各个字符，包括空格
  6.     {
  7.         Init(&L);                                  //我们先初始化栈L
  8.         int flag=1;                                //这个变量用来标记括号是否匹配成功
  9.         for(int i=0;s[i]!='\0';i++)                //循环遍历我们输入的算术表达式中的括号
  10.         {          
  11.             if(s[i]=='('||s[i]=='['||s[i]=='{')    //如果是左括号我们就看能不能让它入栈
  12.             {
  13.                 if(L.top<Maxsize)                  //栈没满我们就让左括号进栈，调用Push函数
  14.                 {
  15.                     char x=s[i];
  16.                     //进栈
  17.                     Push(&L,x);
  18.                 }
  19.  
  20.             }
  21.             else if(s[i]==')')                      //如果栈是这个右括号，就判断栈是否为空
  22.             {
  23.                 if(Empty(L))                        //栈为空，我们就标记flag=0，结束循环，括号不匹配
  24.                 {
  25.                     flag=0;
  26.                     break;
  27.                 }
  28.                 else                                 //栈不空，我们就获取栈顶元素，调用Get函数
  29.                 {
  30.                     if(Get(L)=='(')                  //括号匹配了，调用Pop函数，将左括号出栈
  31.                     {
  32.                         Pop(&L);
  33.                     }
  34.                     else                              //括号不匹配，那我们标记flag=0，结束循环，括号不匹配
  35.                     {
  36.                         flag=0;
  37.                         break;
  38.                     }
  39.                 }
  40.             }
  41.             else if(s[i]=='}')                           //接下来的两个else  if和上面的思想一致。
  42.             {
  43.  
  44.                 if(Empty(L))
  45.                 {
  46.                     flag=0;
  47.                     break;
  48.                 }
  49.                 else   //问题就出在这一句上
  50.                 {
  51.                     if(Get(L)=='{')
  52.                     {
  53.                         Pop(&L);
  54.                     }
  55.                     else
  56.                     {
  57.                         flag=0;
  58.                         break;
  59.                     }
  60.                 }
  61.             }
  62.             else if(s[i]==']')
  63.             {
  64.  
  65.                 if(Empty(L))
  66.                 {
  67.                     flag=0;
  68.                     break;
  69.                 }
  70.                 else
  71.                 {
  72.                     if(Get(L)=='[')
  73.                     {
  74.                         Pop(&L);
  75.                     }
  76.                     else
  77.                     {
  78.                         flag=0;
  79.                         break;
  80.                     }
  81.                 }
  82.             }
  83.         }
  84.         if(!Empty(L))                                   //遍历完算术表达式之后，判断栈是否为空，如果不为空，标记flag=0；
  85.         {
  86.             flag=0;
  87.         }
  88.         if(flag==1&&Empty(L))                  //只有flag=1并且栈是空的，我们才能说我们输入的括号是完全匹配的
  89.         {
  90.             printf("yes\n");
  91.         }
  92.         else                       
  93.         {
  94.             printf("no\n");
  95.         }
  96.     }
  97.     return 0;
  98. }

（八）、运行结果

 四、完整代码

  1.  
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #define Maxsize 100
  5. typedef struct ST
  6. {
  7.     char data[Maxsize];
  8.     int  top;
  9. }Stack;
  10. void Init(Stack *L)
  11. {
  12.     L->top=-1;
  13. }
  14. void Push(Stack *L,char x)
  15. {
  16.     if(L->top>=Maxsize)
  17.     {
  18.         return;
  19.     }
  20.     L->top++;
  21.     L->data[L->top]=x;
  22. }
  23. int Empty(Stack L)
  24. {
  25.     if(L.top==-1)
  26.     {
  27.         return 1;//为空返回1
  28.     }
  29.     return 0;    //不为空返回0
  30. }
  31. void Print(Stack L)
  32. {
  33.     for(int i=L.top;i>-1;i--)
  34.     {
  35.         printf("%c   ",L.data[i]);
  36.     }
  37. }
  38. void Pop(Stack *L)
  39. {
  40.     if(L->top==-1)
  41.     {
  42.         return;
  43.     }
  44.     L->top--;
  45. }
  46. char Get(Stack L)
  47. {
  48.     return L.data[L.top];
  49. }
  50. int main()
  51. {
  52.     Stack L;
  53.     char s[100];
  54.     while(gets(s))
  55.     {
  56.         Init(&L);
  57.         int flag=1;
  58.         //printf("%s",s);
  59.         for(int i=0;s[i]!='\0';i++)
  60.         {
  61.             if(s[i]=='('||s[i]=='['||s[i]=='{')
  62.             {
  63.                 if(L.top<Maxsize)
  64.                 {
  65.                     char x=s[i];
  66.                     Push(&L,x);
  67.                 }
  68.  
  69.             }
  70.             else if(s[i]==')')
  71.             {
  72.  
  73.                 if(Empty(L))
  74.                 {
  75.                     flag=0;
  76.                     break;
  77.                 }
  78.                 else  
  79.                 {
  80.                     if(Get(L)=='(')
  81.                     {
  82.                         Pop(&L);
  83.                     }
  84.                     else
  85.                     {
  86.                         flag=0;
  87.                         break;
  88.                     }
  89.                 }
  90.             }
  91.             else if(s[i]=='}')
  92.             {
  93.  
  94.                 if(Empty(L))
  95.                 {
  96.                     flag=0;
  97.                     break;
  98.                 }
  99.                 else   
  100.                 {
  101.                     if(Get(L)=='{')
  102.                     {
  103.                         Pop(&L);
  104.                     }
  105.                     else
  106.                     {
  107.                         flag=0;
  108.                         break;
  109.                     }
  110.                 }
  111.             }
  112.             else if(s[i]==']')
  113.             {
  114.                 if(Empty(L))
  115.                 {
  116.                     flag=0;
  117.                     break;
  118.                 }
  119.                 else   
  120.                 {
  121.                     if(Get(L)=='[')
  122.                     {
  123.                         Pop(&L);
  124.                     }
  125.                     else
  126.                     {
  127.                         flag=0;
  128.                         break;
  129.                     }
  130.                 }
  131.             }
  132.         }
  133.         if(!Empty(L))
  134.         {
  135.             flag=0;
  136.         }
  137.         if(flag==1&&Empty(L))
  138.         {
  139.             printf("yes\n");
  140.         }
  141.         else
  142.         {
  143.             printf("no\n");
  144.         }
  145.     }
  146.     return 0;
  147. }

总结：括号匹配问题比较经典，它完美的考察了我们对栈的理解，熟悉栈的操作是基本的，只有把它结合到具体的问题上加以运用才是真的掌握。理论联系实际，实践是检验真理的唯一标准。继续加油。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Monodyee/article/detail/598450
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号