顺序栈使用——括号匹配的检验

最新推荐文章于 2023-07-09 08:17:58 发布
最新推荐文章于 2023-07-09 08:17:58 发布
阅读量1.4w 收藏 173
点赞数 85
分类专栏： 数据结构 c-c++ 计算机基础 文章标签： c语言 栈 括号匹配
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq923132714/article/details/78677281
版权

顺序栈使用——括号匹配的检验

码文不易，如果帮助到您，希望您可以帮我刷一下点击量，与您无害，与我有益谢谢 支持原创 。

  欢迎大家阅读我的博客，如果有错误请指正，有问题请提问，我会尽我全力改正错误回答问题。在次谢谢大家。下面开始正式内容

  顺序栈部分在之前已经在另一篇文章中提及，本篇中就不再提及，如有需要请阅读<顺序栈的各种基本运算>。


实验环境

  • 语言c/c++
  • 编译器devc++5.11/5.40


实验内容与要求

问题描述：
  假设表达式中允许有两种括号：圆括号和方括号，其嵌套的顺序随意，即（（）[ ]）或[（[ ] [ ]）]等为正确格式，[（ ]）或（（（]均为不正确的格式。检验括号是否匹配的方法可用“期待的紧迫程度”这个概念来描述。例如：考虑下列的括号序列：

[　(　[　]　[　]　)　]
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个括号的期待匹配就成了最急迫的任务了，…… ，依次类推。可见这个处理过程正好和栈的特点相吻合。
读入圆括号和方括号的任意序列，输出“匹配”或“此串括号匹配不合法”。
如：输入（[ ]（）），结果“匹配”
　　输入 [（ ）]，结果“此串括号匹配不合法”


目录

码文不易，如果帮助到您，希望您可以帮我刷一下点击量，与您无害，与我有益谢谢 支持原创 。


实验解析

思路方法

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

定义说明

Stack  opr_stack 栈

  定义常用常量，类型别称


函数说明

运算函数

配对
int CheckMatch(char *s,Stack* opr_stack){
    int i= 0; 
    int length = strlen(s);
    while(i<length){
        if(s[i]=='('||s[i]==')'||s[i]=='{'||s[i]=='}'||s[i]=='['||s[i]==']'){//如果当前字符是运算符.
            switch(s[i]){
                case '(':
                    PushStack(*opr_stack,'(');          
                    break;
                case '[':
                    PushStack(*opr_stack,'[');
                    break;
                case '{':
                    PushStack(*opr_stack,'{');
                    break;
                case ')':
                    if(EmptyStack(*opr_stack)==1&&TopStack(*opr_stack)!='(')
                        return 0;
                    OutStack(*opr_stack);
                    break;
                case ']':
                    if(EmptyStack(*opr_stack)==1&&TopStack(*opr_stack)!='[')
                        return 0;
                    OutStack(*opr_stack);
                    break;
                case '}':
                    if(EmptyStack(*opr_stack)==1&&TopStack(*opr_stack)!='{')
                        return 0;
                    OutStack(*opr_stack);
                    break;
                default:break;
            }
        }
        i++;     
    } 
    if(EmptyStack(*opr_stack)==1) 
        return 1;
    return 0;
}

  进行一步运算，返回结果。调用时注意栈是否为空，没有做安全防护


主函数


int main(){
    Stack opr_stack;
    InitList_stack(opr_stack);
    char s[100] = {0};
    gets(s);    
    printf("结果是：%s",CheckMatch(s,&opr_stack)==1?"匹配":"不匹配");
    return 0;
}


结果展示

括号匹配的检验结果截图


附录

相关资料

  1. 顺序栈的各种基本运算


源代码

码文不易，如果帮助到您，希望您可以帮我刷一下点击量，与您无害，与我有益谢谢 支持原创 。

Stack.h

#include<stdio.h>   //EOF,NULL
#include<malloc.h>  //malloc()
#include<process.h>  //exit()

#define  OK  1
#define  ERROR  0
#define  TRUE  1
#define  FALSE  0

typedef  int  Status;
typedef  double    SElemType;
#define STACK_INIT_SIZE  100   //栈存储空间的初始分配量
#define STACKINCREMENT  10   //存储空间分配增量
typedef struct{
   SElemType  *base;             //存储数据元素的数组
   SElemType  *top;              //栈顶指针
   int stacksize;                   //当前分配的栈空间大小
                                 //（以sizeof(SElemType)为单位）
}Stack;


Status InitList_stack (Stack &s) {
    s.base = (SElemType*)malloc( STACK_INIT_SIZE*sizeof(SElemType));
    if (!s.base )   exit(0);
s.stacksize = STACK_INIT_SIZE;
s.top = s.base;

 return OK;
}// InitList_stack
Status EmptyStack (Stack s) 
{ if(s.base == s.top)  return TRUE;
  else return FALSE;
}//
Status PushStack(Stack &s , SElemType e ){
if(s.stacksize<(s.top-s.base) )return ERROR;
if(s.stacksize==(s.top-s.base) )
s.base = (SElemType*)malloc(( s.stacksize+STACKINCREMENT)*sizeof(SElemType));

        *(s.top) = e;
        s.top++;

    return OK;

}
Status GetLength(Stack s){
    return s.top-s.base;
}
Status DisplayStack(Stack &s){

    while(s.base != s.top){

        printf("%c ",*--(s.top));

    }
    printf("\n");
}
SElemType OutStack(Stack &s ){
 SElemType  e;
    if(s.top != s.base)

 e= *(--s.top);

    return e;
}
SElemType TopStack(Stack &s ){
 SElemType  e;
    if(s.top != s.base)

 e= *(s.top-1);

    return e;
}
Status DestroyStack ( Stack s) 
{      if (!s.base)  return ERROR; 
      free (s.base);    
      s.base = NULL;
      s.top = NULL;
      s.stacksize= 0;
      return OK;
}// DestroyList_Sq

main.cpp

#include "Stack.h"

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



int CheckMatch(char *s,Stack* opr_stack){
    int i= 0; 
    int length = strlen(s);
    while(i<length){
        if(s[i]=='('||s[i]==')'||s[i]=='{'||s[i]=='}'||s[i]=='['||s[i]==']'){//如果当前字符是运算符.
            switch(s[i]){
                case '('://如果是加号.
                    PushStack(*opr_stack,'(');          
                    break;
                case '['://如果是减号.
                    PushStack(*opr_stack,'[');
                    break;
                case '{'://如果是乘号.
                    PushStack(*opr_stack,'{');
                    break;
                case ')'://如果是除号.
                    if(EmptyStack(*opr_stack)==1&&TopStack(*opr_stack)!='(')
                        return 0;
                    OutStack(*opr_stack);
                    break;
                case ']'://如果是除号.
                    if(EmptyStack(*opr_stack)==1&&TopStack(*opr_stack)!='[')
                        return 0;
                    OutStack(*opr_stack);
                    break;
                case '}'://如果是除号.
                    if(EmptyStack(*opr_stack)==1&&TopStack(*opr_stack)!='{')
                        return 0;
                    OutStack(*opr_stack);
                    break;
                default:break;
            }
        }
        i++;     
    } 
    if(EmptyStack(*opr_stack)==1) 
        return 1;
}   


int main(){
    Stack opr_stack;
    InitList_stack(opr_stack);
    char s[100] = {0};
    gets(s);    
    printf("结果是：%s",CheckMatch(s,&opr_stack)==1?"匹配":"不匹配");
    return 0;
}

码文不易，如果帮助到您，希望您可以帮我刷一下点击量，与您无害，与我有益谢谢 支持原创 。

logic923
关注
  • 85
    点赞
  • 踩
  • 173
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
判断输入的表达式中括号是否配对
05-24
编写一个算法判断输入的表达式中括号是否配对（例如：exp=“<{([])}>”）。
C++数据结构——括号匹配检验
weixin_44546342的博客
04-15 4450
习题3-4 括号匹配检验 假设一个算术表达式中可以包含三种括号：圆括号“(”和“)” 、方圆括号“[”和“]”、和花括号“{”和“}”，且这三种括号可按任意的次序嵌套使用(如：…[…{…}…[…]…]…[…]…(…)…)。编写判别给定表达式中所含括号是否正确配对出现的算法。若正确配对则输出yes，否则输出no。注意，算术表达式可能没有括号，也可能不合法（不需要判断）。 输入格式: 测试数据有多组，处理到文件尾。每组测试数据输入不超过50个字符的算术表达式。 输出格式: 对于每组测试，根据算术表达式
【C++题解】括号（括弧）匹配问题综合
最新发布
szxguagua0807的博客
07-09 3625
假设一个表达式有英文字母（小写）、运算符（$+$，$—$，$\times$，$÷$）和左右小（圆）括号构成，假设表达式中允许包含两种括号：圆括号和方括号，其嵌套的顺序随意，如$([]())$或$[([][])]$等为正确的匹配，$[(])$或$([]()$或$(())))$均为错误的匹配。 字符串中只含有括号$()$ ，$[]$ ，$$，$\{\}$ ,判断输入的字符串中括号是否匹配。 如果括号有互相包含的形式，从内到外必须是$()$ ，$[]$ ，$$，$\{\}$给你一个括号序列，其中有圆括号$
1070: C++：泛型编程stack（括号匹配）
m0_51374762的博客
03-20 154
题目描述 假设表达式中包含一种括号：圆括号，其嵌套顺序随意，即(()())或(())等为正确的格式，)(或((())或())均为不正确的格式。检验括号是否匹配可以用堆栈来实现当遇到 ( 时进栈，遇到 ) 时出栈进行匹配检验，如果出现不匹配的情况立即结束，否则继续取下一个字符。如果没有遇到不匹配的情况，最后判断栈是否为空，栈为空，括号匹配,否则不匹配。 输入 包括多组数据。每组1行，为包含括号的表达式。 输出 如果是正确的格式，输出“Yes”，否则输出“No” 样例输入 Copy (()()) (()) ((
括弧匹配检验：比较基础的栈
hezhixingde的博客
08-25 1233
括弧匹配检验： 题目描述 假设表达式中允许包含两种括号：圆括号和方括号，其嵌套的顺序随意，如（［ ］（））或［（［ ］［ ］）］等为正确的匹配，［（ ]）或（［ ］（ ）或 ( ( ) ) ）均为错误的匹配。现在的问题是，要求检验一个给定表达式中的括弧是否正确匹配？输入一个只包含圆括号和方括号的字符串，判断字符串中的括号是否匹配，匹配就输出 “OK” ，不匹配就输出“Wrong”。 输入一个字符串：［（［］［］）］，输出：OK 输入 输入仅一行字符（字符个数小于255） 输出 匹配就输出 “OK” ，不匹配
一本通数据结构——栈的习题，很全，希望您能喜欢
08-10
在计算机科学中，栈的应用非常广泛，包括括号匹配、递归、内存管理、函数调用等。 《一本通数据结构——栈的习题》可能涵盖了栈的各种基础和进阶问题，旨在帮助学习者深入理解栈的原理和应用。通过这些习题，你可以...
数据结构实验——栈子系统
07-31
在计算机科学中，栈被广泛应用，如括号匹配、表达式求值、递归调用等。 实验的目标是掌握栈的特点以及如何用链式存储结构来实现栈。链栈相较于顺序栈，更灵活且在动态扩展时效率更高。链栈由一系列节点组成，每个...
实验报告——栈和队列的应用.pdf
11-10
在实际编程中，理解和正确实现栈和队列的操作至关重要，因为它们是许多复杂算法的基础，如括号匹配、深度优先搜索（DFS）和广度优先搜索（BFS）。同时，错误处理和边界条件的检查也是确保程序正确性的关键。在程序...
MFC数据结构算法实验括弧匹配问题
06-29
本实验专注于一个经典问题——括号匹配，这是许多编译器、解释器和文本编辑器等程序中的核心部分。括号匹配算法用于检查一组括号（如圆括号"()"、方括号"[]"和大括号"{}"）是否正确配对，即每个打开的括号都有一个...
第二次上机1
08-03
总结来说，这次上机实验涵盖了数据结构中的堆栈和队列，以及一个实际问题——括号匹配的算法设计。这些内容不仅锻炼了我们的编程能力，还加深了对数据结构和算法的理解，对于提升问题解决能力有着重要的作用。在实施...
c++判断括号是否匹配
dcjmessi的博客
03-01 4917
输入n组字符串，测试三种括号{}、[]、()，顺序只能是前左括号，后右括号，括号间可以嵌套，若匹配输出yes，否则输出no 输入样例： 2 {a}【b】(d) {[(]} 输出样例： yes no 注意：需加头文件 #include <cstring> int main() { int n, k=0, len, flag=0; //flag标记是否有未匹配的括号 ...
利用顺序栈实现：判别表达式中括弧是否正确配对（BracketMatch函数）
TysonSir的博客
03-30 3778
/*假设一个算数表达式中包含圆括弧、方括弧和花括弧三种类型的括弧，编写一个判别表达式中 括弧是否正确配对的BracketMatch函数。*/ int BracketMatch(SElemType *str);
C++ 判断括号匹配
Destiny_xt的博客
06-22 481
C++判断括号匹配
C++括号匹配的检验
weixin_42694505的博客
12-11 2152
假设表达式中包含三种括号，其嵌套顺序任意，即[]({[]})、([({})])为正确格式，{{[])、}()[]为不正确的格式，检查括号是否匹配，基于C++实现，使用STL实现的stack进行实现； #include &lt;iostream&gt; #include &lt;vector&gt; #include &lt;stack&gt; #include &lt;string&gt; ...
数据结构 括号匹配题解(深学思维)
HackerYY的博客
06-26 1586
基本数据结构栈 包含栈的讲解 AC代码
【实验报告】实验三顺序栈实现括号匹配
whyxian的博客
01-30 2511
顺序栈实现括号匹配 一、需求分析 1、数据存储结构为栈 2、输入形式为键盘 3、输出形式为打印形式 4、包含栈的基本操作 5、能够完成指定要求的括号匹配操作 二、概要设计 一、抽象数据类型定义 ADT Stack { 数据对象：D = {ai | ai ∈ ElemSet，i = 1,2,3,…,n, n ≥ 0} 数据关系： R1={<ai-1, ai> | ai-1 , ai∈D，i=2，…，n} // ai-1为前驱，ai为后继，约定 an 端为栈顶，a1 端为栈底 基本操作： Init
栈练习之Example001-判断一个算术表达式中的括号是否正确配对
二木成林
04-23 8047
C 语言中算术表达式中的括号只有小括号。编写算法，判断一个表达式中的括号是否正确配对，表达式已经存入字符数组 `exp[]` 中，表达式的字符个数为 `n`。
C++ 18.7 输入表达式，判断:"()、{}、[] "三种括号是否匹配
Fuguir™的博客
03-31 1336
C++ 18.7 输入表达式，判断:"()、{}、[] "三种括号是否匹配 //括号匹配 int main() { int n;//输入个数 string a; cin >> n; while(n--) { cin >> a;//输入表达式 int len = a.length();//求表...
括号匹配及表达式求值
m0_68875132的博客
04-20 438
其嵌套顺序任意，即{ ( ( [ ] ) ) }或{ ( [ ] [ ] )}等均为正确的格式，{ ) [ ] ( }或{ [ ] ( ) {等均为不正确的格式。3.若扫描到运算符或者界限符，则按照“中缀转后缀”相同的逻辑压入运算符栈（期间也会弹出运算符，每当弹出一个运算符，就需要弹出两个操作数栈的栈顶元素并执行相应的运算，运算结果再压回操作数栈）。时，遇到“(”直接入栈，遇到“)”则依次弹出栈内运算符并加入后缀表达式，直到弹出“(”为止。3.扫描到右括号，则弹出栈顶元素（已入栈的左括号）。
（1）采用链式存储实现栈的初始化、入栈、出栈操作。 （2）给定一个括号序列，里面包括圆括号和方括号，编程检验该括号序列中括号是否 配对
05-15
好的，下面是代码实现： ```C++ #include <iostream> using namespace std; const int MAXSIZE = 100; // 栈的最大容量 template <typename T> class Stack { private: T data[MAXSIZE]; // 存储栈元素的数组 int top; // 栈顶指针 public: Stack() { top = -1; } // 构造函数，将栈顶指针初始化为-1 bool isEmpty() { return top == -1; } // 判断栈是否为空 bool isFull() { return top == MAXSIZE - 1; } // 判断栈是否已满 void push(T x) { // 入栈操作 if (isFull()) { cout << "Stack Overflow" << endl; return; } data[++top] = x; } T pop() { // 出栈操作 if (isEmpty()) { cout << "Stack Underflow" << endl; return -1; } return data[top--]; } }; bool check(string str) { // 括号匹配检查函数 Stack<char> stk; for (int i = 0; i < str.size(); i++) { if (str[i] == '(' || str[i] == '[') { // 左括号入栈 stk.push(str[i]); } else if (str[i] == ')') { // 右圆括号出栈匹配 if (stk.isEmpty()) return false; // 栈为空，无法匹配 if (stk.pop() != '(') return false; // 栈顶元素不是左圆括号，匹配失败 } else if (str[i] == ']') { // 右方括号出栈匹配 if (stk.isEmpty()) return false; // 栈为空，无法匹配 if (stk.pop() != '[') return false; // 栈顶元素不是左方括号，匹配失败 } } return stk.isEmpty(); // 最后栈为空，匹配成功；否则，匹配失败 } int main() { string str = "[()]{}{[()()]()}"; if (check(str)) { cout << "The parentheses are matched." << endl; } else { cout << "The parentheses are not matched." << endl; } return 0; } ``` 运行结果： ``` The parentheses are matched. ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值