精华内容
下载资源
问答
  • 使用顺序栈实现括号匹配
  • 顺序栈实现括号匹配

    千次阅读 2016-05-15 11:33:58
    //采用顺序栈编程实现:表达式的括号是否匹配问题。 //要求:输入带括号的表达式,判断其中括号是否配对。 //扩展功能:给出配对括号的位序和不配对括号的位序。#include #include #include #include #include ...
    //采用顺序栈编程实现:表达式的括号是否匹配问题。
    //要求:输入带括号的表达式,判断其中括号是否配对。
    //扩展功能:给出配对括号的位序和不配对括号的位序。
    
    #include <iostream>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <algorithm>
    #define OVERFLOW -2
    #define STACK_INIT_SIZE 100
    #define STACKINCREMENT 10
    #define ERROR 0
    #define OK 1
    using namespace std;
    typedef struct
    {
        char c;
        int pos;
    } Brack,*Bracket;
    
    typedef struct
    {
        Bracket base;
        Bracket top;
        int stacksize;
    } SqStack;
    
    int InitStack(SqStack &S)
    {
        S.base=(Bracket)malloc(STACK_INIT_SIZE*sizeof(Brack));
        if(!S.base)
            return  ERROR;
        S.top=S.base;
        S.stacksize=STACK_INIT_SIZE;
        return OK;
    }
    
    Brack GetTop(SqStack S,Brack e)
    {
        if(S.top==S.base)
            exit(OVERFLOW);
        S.top--;
        e=*S.top;
        return e;
    }
    
    int Push(SqStack &S,Brack e)
    {
        if(S.top-S.base>=S.stacksize)
        {
            S.base=(Bracket)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(Brack));
            if(!S.base)
                exit(OVERFLOW);
            S.top=S.base+S.stacksize;
            S.stacksize+=STACKINCREMENT;
        }
        *S.top=e;
        S.top++;
        return OK;
    }
    
    int Pop(SqStack &S, Brack &e)
    {
        if(S.base==S.top)
            return ERROR;
        e=*(S.top-1);
        S.top--;
        return OK;
    }
    
    bool equal_e(char a,char b)
    {
        if(a=='('&&b==')')
            return true;
        else if(a=='{'&&b=='}')
            return true;
        else if(a=='['&&b==']')
            return true;
        else
            return false;
    }
    
    char ch[100];
    int match[100];
    int nomatch[100];
    int p=0,q=0;
    bool find_brack(SqStack S,char e)
    {
        int flag=0;
        while(S.base!=S.top)
        {
            S.top--;
            if(equal_e(S.top->c,e))
            {
                flag=1;
                match[p++]=S.top->pos;
                break;
            }
        }
        if(flag==1)
            return true;
        else
            return false;
    }
    void fun()
    {
        SqStack S;
        InitStack(S);
        Brack b;
        for(int i=0; i<strlen(ch); i++)
        {
            if(ch[i]=='{'||ch[i]=='('||ch[i]=='[')
            {
                b.c=ch[i];
                b.pos=i+1;
                Push(S,b);
            }
            //GetElem(S);
            if(ch[i]=='}'||ch[i]==')'||ch[i]==']')
            {
                if(find_brack(S,ch[i]))
                {
                    do
                    {
                        Pop(S,b);
                        if(equal_e(b.c,ch[i]))
                        {
                            break;
                        }
                        else
                        {
                            nomatch[q++]=b.pos;
                        }
                    }
                    while(true);
                }
                else
                {
                    nomatch[q++]=i+1;
                    //cout<<"fun"<<i+1<<endl;
                }
            }
        }
        while(S.base!=S.top)
        {
            Pop(S,b);
            nomatch[q++]=b.pos;
        }
        if(q!=0)
        {
            cout<<"括号匹配失败!"<<endl;
            if(p!=0)
            {
                cout<<"匹配成功的括号位序是:"<<endl;
                sort(match,match+p);
                for(int i=0; i<p; i++)
                {
                    cout<<match[i]<<" ";
                }
                cout<<endl;
    
            }
    
            cout<<"匹配不成功的括号位序是:"<<endl;
            sort(nomatch,nomatch+q);
            for(int i=0; i<q; i++)
            {
                cout<<nomatch[i]<<" ";
            }
            cout<<endl;
            cout<<"注:这里的位序是指括号在表达式中的位置顺序!"<<endl;
        }
        else
        {
            cout<<"表达式中的括号均是配对的。"<<endl;
        }
    }
    
    int main()
    {
        cin>>ch;
        fun();
        return 0;
    }
    
    展开全文
  • 利用顺序栈实现括号匹配的检验

    千次阅读 2020-03-20 17:48:51
    利用顺序栈实现括号匹配的检验(严蔚敏版《数据结构》第49页3.2.2) 思路 我的思路是直接入栈和检验同时进行,即:如果两个相近的括号的差值符合要求([ ] 的差值为 2、( ) 的差值为 1),就将此时顺序栈的最上边...

    NOTICE: 本题代码是按照源码顺序贴上的,复制可直接运行

    环境: Visual Stdio Code

     

    题目

    利用顺序栈实现括号匹配的检验(严蔚敏版《数据结构》第49页3.2.2)

    思路

    我的思路是直接入栈和检验同时进行,即:如果两个相近的括号的差值符合要求([ ] 的差值为 2、( ) 的差值为 1),就将此时顺序栈的最上边两个元素出栈,如果 StackLength 为 0, 则证明所有元素均已出栈(即:匹配检验通过),返回成功提醒,否则必须输入‘#’才能停止程序。最后打印出当前的顺序栈(此时如果看到顺序栈不为空,就证明没有通过检验)。

    操作流程示意图:

    emmmm,小编觉得思路还是比较清晰的。

    源码

    初始化:

    #include<stdio.h>
    #include<stdlib.h>
    #include<math.h>
    
    #define STACK_INIT_SIZE 10 // 初始化分配量
    #define STACKINCREMENT 1  // 分配增量
    #define ERROR 0
    #define OK 1
    
    typedef int Status;
    typedef char SElemType;
    
    typedef struct
    {
        SElemType *base;  // 栈底指针
        SElemType *top;   // 栈顶元素
        int stacksize;
    }SqStack;
    
    Status InitStack(SqStack &S)
    {   // 初始化
        S.base = (SElemType *)malloc(STACK_INIT_SIZE * sizeof(SElemType));
        if(!S.base) return ERROR;
        S.top = S.base;
        S.stacksize = STACK_INIT_SIZE;
        return OK;
    }//InitStack

    销毁:

    Status DestroyStack(SqStack &S)
    {   // 销毁
        if(S.base)
        {
            delete S.base;  // C++ 中用来释放之前动态分配的内存
            S.stacksize = 0;
            S.base = S.top = NULL;
        }
        return OK;
    }//DestroyStack

    判断是否为空栈:

    Status StackEmpty(SqStack &S)
    {   // 判断是否为空栈
        if(S.top == S.base) return OK;
        else return ERROR;
    }//StackEmpty

    获取栈容量:

    Status StackLength(SqStack &S)
    {   // 获取栈容量
        return S.top - S.base;
    }//StackLength
    

    入栈:

    Status Push(SqStack &S, SElemType *e)
    {   // 入栈
        if(S.top - S.base == S.stacksize)
        {
            S.base = (SElemType *)realloc(S.base, (S.stacksize + STACKINCREMENT) * sizeof(SElemType));
            if(!S.base) return ERROR;
            S.top = S.base + S.stacksize;
            S.stacksize += STACKINCREMENT;
        }
        *S.top ++= *e;
        return OK;
    }//Push

    出栈:

    Status Pop(SqStack &S, SElemType *e)
    {   // 出栈
        if(S.top == S.base) return ERROR;
        *e = *--S.top;
        return OK;
    }//Pop

    打印栈:

    Status StackTraverse(SqStack &S)
    {   // 打印
        SElemType *p = (SElemType *)malloc(sizeof(SElemType));
        p = S.top;
        if(!p) return ERROR;
        else
        {
            p--;
            while(p >= S.base)
            {
                printf("%c ", *p);
                p--;
            }
        }
        return OK;
    }//StackTraverse

    获取栈顶元素:

    Status GetTop(SqStack &S, SElemType *e)
    {   // 若栈不空,用 e 返回 S 的栈顶元素,并返回 OK,否则返回 ERROR
        if(S.top == S.base) return ERROR;
        *e = *(S.top-1);
        return OK;
    }//GetTop

    检验:

    Status Judge(SqStack &S)
    {   // 括号匹配检验
        SElemType e, out;
        // 入栈、判断
        printf("\n请依次输入想要检验的括号(输入 # 结束):\n");    
        while(e != '#')    // 如果匹配不通过,必须手动输入 # 来结束程序
        {
            printf("\n请输入入栈元素:\n");
            scanf("%c", &e);
            getchar();
            if(e == '#') break;       // 我发现不写这行会出现一个问题,就是输入一个 # 不会退出
            if(StackLength(S) >= 0)     
            {
                int i = 0;
                GetTop(S, &out);       // 获取当前栈顶元素
                Push(S, &e);            // 入栈
                printf("\n栈顶元素与输入元素的差的绝对值为:%d\n",abs(out-e));   // 如上文分析所说,'[' - ']' = 2, '(' - ')' = 1
                if(abs(out-e) == 1 || abs(out-e) == 2)  // 如果括号匹配通过
                {
                    while(i != 2)         // 之所以出栈两次是因为,新的元素已经插入,此时栈顶两个元素是匹配成功的,删除的是这两个元素
                    {
                        Pop(S, &out);         
                        printf("\n出栈元素为:%c\n", out);
                        i ++;
                    }
                    if(StackEmpty(S))    // 顺序栈为空,跳出循环,提示通过
                    {
                        printf("\n检验通过!\n");
                        break;
                    }
                    continue;
                }
                printf("\n栈容量:%d\n", StackLength(S));     // 可以不要,我只是想直观地看一下栈当前容量
            }
        }
        printf("\n栈的当前容量为:%d\n", StackLength(S));       // 从这行往下都是最后返回栈元素的语句,目的是当匹配不通过时返回所有元素
        printf("\n------------------------------------\n");
        {   // 出栈,查看当前剩余元素
            printf("\n栈的元素为:\n");
            while(S.top != S.base)
            {
                Pop(S, &e);
                printf("%c ", e);
            }
        }
        return OK;
    }//Judge

    主函数:

    int main()
    {
        SqStack S;
        
        if(InitStack(S)) printf("\n初始化成功!\n");
        else exit(0);
        Judge(S);
        DestroyStack(S);      // 要养成用完即销毁的好习惯,虽然现在的计算机会自动销毁,但是养成这个好习惯还是没坏处的
        return OK;
    }

    运行结果示意图:

    我不晓得怎么截取长图.......

    THE END!

    展开全文
  • 2018-11-11-14:28:31 1.顺序栈 下面是我用数组实现的顺序栈,包含的函数有出入栈,查看栈顶元素,栈的大小,栈是否空等函数,当栈空间不够用时,对应的数组会自动... 2 顺序栈实现括号匹配。 3 main函数操作:...

    2018-11-11-14:28:31

    1.顺序栈

    下面是我用数组实现的顺序栈,包含的函数有出入栈,查看栈顶元素,栈的大小,栈是否空等函数,当栈空间不够用时,对应的数组会自动增长。

     

      1 /*********************************************************
      2     顺序栈实现括号匹配。
      3     main函数操作:
      4         1.在这里main函数内部主要以解决括号匹配问题。
      5         2.本例中包含"()""[]"{}"三种括号。
      6         3.输入一个表达式,如果括号匹配则输出True,否则输出False。
      7 **********************************************************/
      8 #include <cstdio>
      9 #include <cstring>
     10 #include <cstdlib>
     11 #include <iostream>
     12 using namespace std;
     13 typedef char SElemtype;
     14 #define INITSTACKSIZE 100
     15 #define STACKINCRESMENT 40
     16 #define OverFlow -1
     17 typedef struct {
     18     SElemtype*Top;//指向栈顶
     19     SElemtype*Base;//指向栈底
     20     int Stacksize;//以sizeof(SElemtype)为单位
     21 }Stack;
     22 
     23 bool InitStack(Stack&S);
     24 bool StackEmpty(Stack S);
     25 int StackLength(Stack S);
     26 bool GetTop(Stack S,SElemtype&Elem);
     27 bool Push(Stack&S,SElemtype Elem);
     28 bool Pop(Stack&S,SElemtype&Elem);
     29 bool PrintStack(Stack S);
     30 //main函数内所有数据均为测试数据,读者可根据自己测试方式自行调换
     31 
     32 int main()
     33 {
     34     Stack S;
     35     InitStack(S);
     36     char c;
     37     string str;
     38     cin>>str;
     39     for(int i=0;i<str.length();i++){
     40         if(str[i]=='('||str[i]=='['||str[i]=='{'){
     41             Push(S,str[i]);
     42             continue;
     43         }
     44         if(str[i]==')'){
     45             GetTop(S,c);
     46             if(c=='(')  Pop(S,c);
     47             if(c=='['||c=='{')  break;
     48         }
     49         if(str[i]==']'){
     50             GetTop(S,c);
     51             if(c=='[')  Pop(S,c);
     52             if(c=='('||c=='{')  break;
     53         }
     54         if(str[i]=='}'){
     55             GetTop(S,c);
     56             if(c=='{')  Pop(S,c);
     57             if(c=='('||c=='[')  break;
     58         }
     59     }
     60     if(StackEmpty(S))
     61        cout<<"True"<<endl;
     62     else
     63         cout<<"False"<<endl;
     64     return 0;
     65 }
     66 bool InitStack(Stack&S){
     67     S.Base=(SElemtype*)malloc(INITSTACKSIZE*sizeof(SElemtype));
     68     if(!S.Base)
     69         exit(OverFlow);//程序异常终止
     70     S.Top=S.Base;
     71     S.Stacksize=INITSTACKSIZE;
     72     return true;
     73 }
     74 
     75 bool StackEmpty(Stack S){
     76     if(S.Top==S.Base)
     77         return true;
     78     else
     79         return false;
     80 }
     81 
     82 int StackLength(Stack S){
     83     int Length=0;
     84     SElemtype*index;
     85     for(index=S.Top;index!=S.Base;index--)
     86         Length++;
     87     return Length;
     88 }
     89 
     90 bool GetTop(Stack S,SElemtype&Elem){
     91     if(S.Top==S.Base)
     92        return false;
     93     else{
     94         Elem=*(S.Top-1);
     95         return true;
     96     }
     97 }
     98 
     99 bool Push(Stack&S,SElemtype Elem){
    100     if(S.Top-S.Base>=S.Stacksize){
    101         S.Base=(SElemtype*)realloc(S.Base,(S.Stacksize+STACKINCRESMENT)*sizeof(SElemtype));
    102         if(!S.Base)
    103             exit(OverFlow);
    104         S.Top=S.Base+S.Stacksize;
    105         S.Stacksize+=STACKINCRESMENT;
    106     }
    107     *S.Top++=Elem;
    108     return true;
    109 }
    110 
    111 bool Pop(Stack&S,SElemtype&Elem){
    112     if(S.Base==S.Top)
    113         return false;
    114     else
    115         Elem=*--S.Top;
    116     return true;
    117 }
    118 
    119 /****************************************
    120     Author:CRUEL_KING
    121     Time:2018/11/10
    122     Program name:顺序栈实现括号匹配.cpp
    123 ****************************************/

     2.STL之Stack

      stack是一种容器适配器(STL的容器分为顺序容器和关联容器,容器适配器,是对这两类容器进行包装得到的具有更强的约束力的容器),被设计来用于操作先进后出(FILO)结构的情景,在这种情况下, 元素的插入和删除都只能在容器的尾部进行。stack通过容器适配器来实现,是一种将特定的容器类作为其最底层的容器的类,它提供了一些特定的成员函数来访问自己的元素,元素只能在这个特定容器的后面,也就是栈的顶部,进行出栈和入栈操作。 

      构造:template <class T, class Container = deque<T> > class stack;

      如上,这对尖括号中有两个参数,第一个是T,表示栈中存放的数据的类型,比如int,double,或者结构体之类。

      第二个参数指明底层实现的容器类型,也就是指明这个栈的内部实现方式,比如vector,deque,list。如果不指明它,默认使用deque(双端队列)。

      栈的成员函数和基本操作:

        1.定义栈

    1 stack<data_type>name;//如:stack<int>z;定义一个数据类型为data_type的栈name。

     

        2.复制栈

    1 stack<data_type>name(name2);//如:stack<int>z(z2);将栈name2中的元素复制到一个新栈name中。

        3.入栈

    1 name.push(variable);//如:z.push(a);将a压入栈z的顶端。

        4.出栈(栈不为空的情况下)

    1 name.pop();//如:z.pop();弹出一个z栈的栈顶元素。

        5.查看栈顶元素(栈不为空的情况下)

    1 variable=name.top();//如:k=z.top();将z栈的栈顶元素赋值给一个变量k。

        6.栈的元素个数

    1 variable=name.size();//如:k=z.size();将z栈的元素个数赋值给一个变量k。

     

        7.检验栈是否为空

    1 name.empty();//如:z.empty();检验栈是否为空,空返回为1,非空返回为0;

     

      例题详解(括号匹配)

     1 /*********************************************************
     2     STL_Stack栈实现括号匹配。
     3     main函数操作:
     4         1.在这里main函数内部主要以解决括号匹配问题。
     5         2.本例中包含"()""[]"{}"三种括号。
     6         3.输入一个表达式,如果括号匹配则输出True,否则输出False。
     7 **********************************************************/
     8 #include <cstdio>
     9 #include <cstring>
    10 #include <stack>
    11 #include <iostream>
    12 using namespace std;
    13 
    14 int main()
    15 {
    16     stack <char>S;
    17     char c;
    18     string str;
    19     cin>>str;
    20     for(int i=0;i<str.length();i++){
    21         if(str[i]=='('||str[i]=='['||str[i]=='{'){
    22             S.push(str[i]);
    23             continue;
    24         }
    25         if(str[i]==')'){
    26             c=S.top();
    27             if(c=='(')  S.pop();
    28             if(c=='['||c=='{')  break;
    29         }
    30         if(str[i]==']'){
    31             c=S.top();
    32             if(c=='[')  S.pop();
    33             if(c=='('||c=='{')  break;
    34         }
    35         if(str[i]=='}'){
    36             c=S.top();
    37             if(c=='{')  S.pop();
    38             if(c=='('||c=='[')  break;
    39         }
    40     }
    41     if(S.empty())
    42        cout<<"True"<<endl;
    43     else
    44         cout<<"False"<<endl;
    45     return 0;
    46 }
    47 
    48 
    49 /****************************************
    50     Author:CRUEL_KING
    51     Time:2018/11/11
    52     Program name:STL栈实现括号匹配.cpp
    53 ****************************************/

     

    转载于:https://www.cnblogs.com/bianjunting/p/9940721.html

    展开全文
  • 顺序栈的方法实现括号匹配的检查,例如输入( enter【enter{enter}enter】enter)enter,程序就会输出Match(匹配),注enter是回车。
  • 利用顺序栈实现括号匹配

    千次阅读 2017-11-09 20:59:01
    printf("括号匹配成功"); return OK; } else printf("括号匹配失败"); return ERROR; } void main(){ char str[100]; SqStack S; InitStack (S); printf("请输入...
    #include <stdio.h>
    #include <stdlib.h>
    #include <malloc.h>
    #include <string.h>


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


    #define STACK_INIT_SIZE 300//存储空间初始化分配量
    #define STACKINCREMENT 30//存储空间分配增量
    #define MAXLEN 10
    typedef int Status;
     




    typedef char ElemType;


    typedef struct{           //构建一个栈
    ElemType  *base;    
        ElemType  *top;  
        int  stacksize;    
      } SqStack;




    Status InitStack(SqStack &S) //初始化栈
    {
    S.base=(ElemType*)malloc(STACK_INIT_SIZE*sizeof(ElemType));
    if(!S.base) exit(OVERFLOW);
    S.top=S.base;
    S.stacksize=STACK_INIT_SIZE;
    return OK;
    };


    Status Push(SqStack &S, ElemType e){  //入栈
    if (S.top-S.base>=S.stacksize){//栈满,追加存储空间
    S.base=(ElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof (ElemType));
    if(!S.base)exit(OVERFLOW); //存储分配失败
           S.top =S.base+S.stacksize;
           S.stacksize+=STACKINCREMENT;
    }
       *S.top++ =e;
        return OK;

    }




    Status Pop(SqStack &S,ElemType &e) {//出栈
        if(S.top==S.base)
    return ERROR;
        e=* --S.top;
        return OK;
    }




    Status StackEmpty(SqStack S) //判断栈是否为空
    {
    if(S.top==S.base) return TRUE;
    else return FALSE;
    };




    Status DestroyStack(SqStack &S)//摧毁栈
    {
    free(S.base);
    S.base=NULL;
    S.top=NULL;
    S.stacksize=0;
    return OK;
    }


    int StackLength(SqStack S) //求栈长
    {
    return S.top-S.base;
    }


    Status GetTop(SqStack S, ElemType &e)  //取栈顶元素
    {
    if (S.top==S.base) return ERROR;
    else
    e=*(S.top-1);
    return OK;
    }


    Status ClearStack(SqStack &S) //清空栈
    {
    S.top = S.base;
    return OK;
    }




    Status StackTravers(SqStack S, Status (*visit)(ElemType)) //遍历栈
    {
    ElemType *p=S.base;
    if (S.top==S.base) return ERROR;
    do
    {
    if (!visit(*p)) return ERROR;
    }while (p++ !=S.top );
    return OK;
    }
    Status matching(SqStack S,char *exp)
    {
    int i=0;
    char e;
    while(i<strlen(exp)) {
         switch (exp[i]) {
    case '(':
    case '[':
    case '{':
    {Push(S,exp[i]); i++; break;}
        case ')':
        case ']':
            case '}':
    if(StackEmpty(S)) 
    {
    printf("括号匹配失败");
    return ERROR;
    }
    else 
    {
    GetTop(S,e);
    if((exp[i]==')' && e=='(') || (exp[i]=='}' && e=='{') || (exp[i]==']' && e=='[')) 
    {
    Pop(S,e);
    i++;
    break;
    }
    else 
    {
    printf("括号匹配失败");
    return ERROR;
    break;
    }
    }
    }
    }
      if (StackEmpty(S))
    {
    printf("括号匹配成功");
    return OK;
    }
    else
    printf("括号匹配失败");
    return ERROR;

    }



    void main(){


    char str[100];
    SqStack S;
    InitStack (S);
    printf("请输入括号\n");
    gets(str);
    matching(S,str);
    }
    展开全文
  • 假设表达式中允许括号嵌套,则检验括号是否匹配的方法可用“期待的急迫程度”这个概念来描述。 我们下面给和例子进行说明: 可能出现的不匹配的情况: ① 盼来的右括号不是所“期待”的; ② 到来的是“不速之客” ...
  • 括号匹配文件:Backets_match.c 1 #include 2 #include "Stack.h" 3 4 void brackets(char *expression) 5 { 6 SeqStack *S; 7 char ch1, ch2; 8 int pos = 1; 9 10 S = (SeqStack *)malloc...
  • 栈实现括号匹配(c语言)

    千次阅读 2020-09-14 15:34:29
    //用顺序栈实现括号匹配 #include<stdio.h> #define MAXSIZE 10 typedef int bool; #define true 1 #define false 0 typedef struct{ char data[MAXSIZE]; //静态数组存放栈中元素 int top
  • C语言实现顺序栈括号匹配

    千次阅读 2015-07-08 21:48:46
    //顺序栈的使用举例:括号匹配 #include #include #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define STACK_INIT_SIZE 100 #define STACKINCREMENT 10 #define BUFFERSIZE 256
  • 毫无疑问,这部分的知识跟编译原理是在一起的。 括号匹配包括数量和形状上的要求,保证左右括号成双成对...编程实现(基于顺序栈): //这次实现中涉及到的括号只包括小中大三种 #include<stdio.h> #include<
  • 每个左括号都必须用正确的顺序闭合。 例如 (]()就不是有效的字符串。 ([]) 正确。 [()]{} 正确。 <p>Input 第一行,一个正整数N,表示有N个测试样例。 接下去N...
  • 题目: 给定一个只包括 ‘(’,’)’,’{’,’...2.左括号必须以正确的顺序闭合。 3.注意空字符串可被认为是有效字符串 实现 import java.util.Stack;//java自带类 class Solution { public boolean isValid(St...
  • #include #include #include #include #include #define OK 1 #define ERROR 0 #define MAXSIZE 100 typedef char ElemType; ...typedef struct stack//创建顺序栈 {  ElemType *b
  • 假设表达式中允许包含三种括号:大括号,中括号和小括号,其中嵌套的顺序随意,即([ ]())或{([ ])}等为正确的格式,[ ( ] ) 或 ( [ ) )均为不正确的格式。检验括号是否匹配的方法可用“期待的急迫程度”这个概念来...
  • 栈实现括号匹配

    千次阅读 2013-04-02 17:41:08
    括号匹配的意思 假设只允许出现两种括号:圆括号和方括号,其嵌套顺序随意,即不管[([])]或[([])]等都为正确匹配,但是形如([][)就成为错误的匹配。 实现的算法 可以用“期待的紧急程度”的概念来描述: ...
  • 括号必须以正确的顺序闭合。 示例 1: 输入:s = “()” 输出:true 示例 2: 输入:s = “()[]{}” 输出:true 示例 3: 输入:s = “(]” 输出:false 示例 4: 输入:s = “([)]” 输出:false 示例 5: 输入:...
  • 【Python】通过栈实现括号匹配

    千次阅读 2018-06-05 11:35:51
    括号匹配 示例: 字符串中有括号”()[]{}”。设计算法,判断该字符串是否有效 括号必须以正确的顺序配对,如:“()”、“()[]”是有效的,但“([)]”无效 Python代码如下: def match_parentheses(s): # ...
  • 给定一个只包括 '(',')','{','}','[',']'的字符串,判断字符串是否有效。 有效字符串需满足: 左括号必须用相同类型的右括号闭合。...解题思路:用来检验括号,这应该是我们学习的时候必学的一道例题了...
  • 数据结构--用栈实现括号匹配的检验目录括号匹配要求程序思路代码实现商务合作及建议 目录 括号匹配要求 假设表达式中允许包含三种括号:{大括号}、[中括号]和(小括号),其嵌套的顺序随意,即{()}、[{([][])}]、({}[]...
  • 设计一个算法判定一个算术表达式中的括号是否正确配对(包括三种括号并且需要考虑大中小三种括号的嵌套顺序)...因此使用一个来存储遍历到的括号,遇到左括号则入栈,遇到右括号,如果匹配当前左括号则出栈,如果不匹
  • 栈实现括号匹配的检验

    千次阅读 2011-02-07 21:59:00
    (一) 问题描述 括号匹配问题是编译程序时经常遇到的问题,用以检测语法是否有错。 (二) 基本要求 1. 用顺序栈来检测括号是否匹配。 2. 令所给的式子中出现()[ ]{ }这几种括号...
  • 顺序栈实现匹配括号功能

    千次阅读 2007-11-12 19:15:00
    //用顺序栈实现匹配括号功能#include #include #define MAXSIZE 100typedef char datatype;typedef struct //定义数据结构{ datatype data[MAXSIZE]; int top;}SeqStack;SeqStack *InitStack(){ SeqStack *s; s...
  • //用可动态分配的一维数组实现栈 #define STACK_INIT_SIZE 100 #define STACKINCREMENT 10 #define OK 0 #define ERROR 1 typedef char SElemType;//////////类型更改为char typedef bool Status; typedef struct { ...
  • 利用顺序栈实现多项式的括号匹配

    千次阅读 2016-11-19 20:13:22
    1.括号匹配函数如下: 2.下面是主函数: 3.源文件与头文件的关系: 4.调用的pop(出栈)函数与push(进栈)函数: void SeqStack::Push(const int& x){ //进栈函数 if(isFull()==true) overflowProcess(); top++; ...
  • #include &lt;stdio.h&gt; #include &...#define STACKINCREAMENT 10//用来的增长 #define MAXSIZE 100 #define OVERFLOW -2 #define OK 1 #define ERROR 0 typedef int status; typ...
  • 假设一个算术表达式中可以包含三种括号:园括号“(”和“)”、方括号“[”和“]”、花括号“{”和“}”,且这三种括号可按任意的次序嵌套使用。编写判别给定表达式中所含...实现顺序栈的基本操作;调用基本操作完成。

空空如也

空空如也

1 2 3 4 5 ... 19
收藏数 366
精华内容 146
关键字:

顺序栈实现括号匹配