匹配括号的判定（C++）

匹配括号的判定
内存限制: 256 Mb时间限制: 1000 ms
题目描述
给定一个由 (，)，[ 与 ] 构成的括号字符串，请判断它是否是匹配的，匹配的定义如下：

[] 与 () 是匹配的；
如果字符串 s 是匹配的，那么 [s] 与 (s) 都是匹配的；
如果字符串 ss 与 tt 都是匹配的，那么 s\cdot ts⋅t 也是匹配的。
输入格式
单独一个字符串：表示输入的序列。

输出格式
如果输入字符串是匹配的，输出 Balanced，否则输出 Unbalanced。
数据范围
设 nn 表示输入字符串的长度

对于 50%50% 的数据，1\leq n\leq 1,0001≤n≤1,000；
对于 100%100% 的数据，1\leq n\leq 1,000,0001≤n≤1,000,000；
样例数据
输入:
[(])
输出:
Unbalanced
输入:
[()]
输出:
Balanced

用栈，如果是左括号就入栈，如果右括号就栈顶元素出栈，判断是否匹配，直到整个字符串匹配完成。

有问题请回复

#include <iostream>
#include <malloc.h>
#define MAXSIZE 100
using namespace std;
char s[1000000];
typedef char datatype;
typedef struct seqstack
{
    datatype elem[MAXSIZE];
    int top;
} seqstack;
void init(seqstack *s)
{
    s->top=-1;
}
int empty(seqstack s)
{
    return(s.top==-1? 1:0);
}
void push(seqstack *s,datatype x)
{
    if(s->top==MAXSIZE-1)
    {
        exit(1);
    }
    s->top++;
    s->elem[s->top]=x;
}
datatype pop(seqstack *s)
{
    datatype x;
    if(s->top==-1)
    {
        exit(1);
    }
    x=s->elem[s->top];
    s->top--;
    return x;
}
int match_kuohao(char c[])
{
    int i=0;
    seqstack *s;
    s=(seqstack *)malloc(sizeof(seqstack));
    init(s);
    while(c[i]!='\0')
    {
        switch(c[i])
        {
            case '{':
            case '[':
            case '(':
                push(s,c[i]);
                break;
            case '}':
                if(!empty(*s) && pop(s)=='{'  ) break;
                else return 0;
            case ']':
                if(!empty(*s) && pop(s)=='['  ) break;
                else return 0;
            case ')':
                if(!empty(*s) && pop(s)=='('  ) break;
                else return 0;
        }
        i++;
    }
    return (empty(*s)==1);
}
int main()
{
    int t=0;
    while((s[t] = getchar()) != '\n')
    {
        t++;
        s[t] = '\0';
    }
    if(match_kuohao(s))
    {
        cout<<"Balanced";
    }
    else
    {
        cout<<"Unbalanced";
    }
    return 0;
}

你看看https://zhuanlan.zhihu.com/p/31574601

#include <iostream>
#include <stack>

int main()
{
    std::stack<char> stack;
    char ch;
    bool unbalanced = false;
    while ((ch = getchar()) != EOF)
    {
        if (ch == '(' || ch == '[')
        {
            stack.push(ch);
        }
        else if (ch == ')' || ch == ']')
        {
            if (!stack.empty() && stack.top() == ch)
            {
                stack.pop();
            }
            else
            {
                unbalanced = true;
                break;
            }
        }
    }
    if (unbalanced || !stack.empty())
        std::cout << "Unbalanced";
    else
        std::cout << "Balanced";
    return 0;
}