@TOC

1. 题目

题目链接：括号匹配问题

2. 思路

用C语言实现，我们需要借助栈这个数据结构，这是C语言比较麻烦之处，我们直接把写好的基本接口直接贴过来。前置文章：栈@栈和队列

根据测试用例，借助栈先进后出的特点
:black_heart: 遇到左括号 —— 入栈
:black_heart: 遇到右括号 —— 弹栈，与该右括号匹配

分析到这里，大致逻辑就写得出来。另外还有两类用例来可能没有一下子想到，没关系，没过补充完善一下就好嘞~

1.如果最后栈不为空，说明当中还有未匹配的左括号。返回false

"["  用例1

2.如果遇到右括号，但是栈为空，说明没有与之匹配的左括号。返回false（足够严谨可以想得到，毕竟要出栈，栈不能为空，为空要提前处理掉，否则会触发断言）

"]"  用例2

注意：所有可能返回地方，返回之前都要把栈销毁，否则内存泄漏

去掉无聊的函数接口的主体代码附在这 ——

bool isValid(char * s){
    ST st;
    StackInit(&st);
    while(*s)
    {
        if(*s == '(' || *s == '['|| *s == '{')
        {
            StackPush(&st,*s);
        }
        else
        {
            if(StackEmpty(&st))
            {
                //遇到右括号，但是栈里面没有数据，
                //说明栈中没有左括号可以与之匹配，返回false
                StackDestroy(&st);
                return false;
            }
            STDataType top = StackTop(&st);
            StackPop(&st);

            if((*s == ')' && top != '(')
            ||(*s == ']' && top != '[')
            ||(*s == '}' && top != '{'))
            {
                //合在一起写
                StackDestroy(&st);
                return false;
            }
        }
        s++;
    }
    //最后栈不为空，说明栈中还有左括号无法被匹配
    if(!StackEmpty(&st))
    {
        StackDestroy(&st);
        return false;
    }
    StackDestroy(&st);
    return true;
}

3. 题解

完整题解在此，去掉无聊的函数接口的主体代码在上一个标题

#define _CRT_SECURE_NO_WARNINGS 1

typedef char STDataType;
typedef struct Stack
{
    STDataType* a;
    int top;//栈顶位置
    int capacity;
}ST;

void StackInit(ST* ps);
void StackDestroy(ST* ps);

//压栈
void StackPush(ST* ps, STDataType x);
//出栈
void StackPop(ST* ps);
//取栈顶数据
STDataType StackTop(ST* ps);
//栈中数据多少？
int StackSize(ST* ps);
//判断栈是否为空
bool StackEmpty(ST* ps);

void StackInit(ST* ps)
{
    assert(ps);
    ps->a = NULL;
    ps->top = 0;
    ps->capacity = 0;
}

void StackDestroy(ST* ps)
{
    assert(ps);
    free(ps->a);
    ps->a = NULL;//有必要，不然就是野指针了
    ps->top = 0;
    ps->capacity = 0;
}

void StackPush(ST* ps, STDataType x)
{
    assert(ps);
    if (ps->top == ps->capacity)
    {
        int newcapacity = (ps->capacity == 0) ? 4 : 2 * ps->capacity;
        STDataType* ptr = (STDataType*)realloc(ps->a, newcapacity *sizeof(STDataType));
        if (ptr == NULL)
        {
            printf("realloc failed\n");
            exit(-1);
        }
        ps->a = ptr;
        ps->capacity = newcapacity;
    }
    ps->a[ps->top] = x;
    ps->top++;
}

void StackPop(ST* ps)
{
    assert(ps);
    assert(!StackEmpty(ps));//断言，栈不为空--这样调用函数不会受到你实现方式的影响
    ps->top--;
}

int StackSize(ST* ps)
{
    assert(ps);
    return ps->top;
}

bool StackEmpty(ST* ps)
{
    assert(ps);
    return ps->top == 0;
}

STDataType StackTop(ST* ps)
{
    assert(ps);
    assert(!StackEmpty(ps));
    return ps->a[ps->top - 1]; // 注意是top - 1
}


bool isValid(char * s){
    ST st;
    StackInit(&st);
    while(*s)
    {
        if(*s == '(' || *s == '['|| *s == '{')
        {
            StackPush(&st,*s);
        }
        else
        {
            if(StackEmpty(&st))
            {
                //遇到右括号，但是栈里面没有数据，
                //说明栈中没有左括号可以与之匹配，返回false
                StackDestroy(&st);
                return false;
            }
            STDataType top = StackTop(&st);
            StackPop(&st);

            if((*s == ')' && top != '(')
            ||(*s == ']' && top != '[')
            ||(*s == '}' && top != '{'))
            {
                //合在一起写
                StackDestroy(&st);
                return false;
            }
        }
        s++;
    }
    //最后栈不为空，说明栈中还有左括号无法被匹配
    if(!StackEmpty(&st))
    {
        StackDestroy(&st);
        return false;
    }
    StackDestroy(&st);
    return true;
}