LEETCODE 20

题目

Given a string containing just the characters ‘(’ , ‘)’ , ‘{’ , ‘}’ , ‘[’ and ‘]’ , determine if the input string is valid.

The brackets must close in the correct order, “()” and “(){}[]” are all valid, but "(]"and “([)]” are not.

题目简化

如果简化成一种括号，只有’(’， ‘)’。在合法的序列中，必然是先出现’(’，再出现’)’。所以：

1. 在任意一个位置上，左括号数量 >= 右括号数量
2. 在最后一个位置上，左括号数量 == 右括号数量
3. 程序中只需要记录左括号数量和右括号数量即可

int isValid(char *str) {
    int lnum = 0, rnum = 0;
    int length = strlen(str);
    for (int i = 0; i < length; i++) {
        switch (str[i]) {
            case '(' : ++lnum; break;
            case ')' : ++rnum; break;
            default : return 0;
        }
        if (lnum >= rnum) continue;
        return 0;
    }
    return lnum == rnum;
}

其中，程序还可以再优化。先出现的是若干’(’，等待’)‘匹配。我们可以只统计待匹配的’('的数量，进行判断。

int isValid(char *str) {
    int lnum = 0;
    int length = strlen(str);
    for (int i = 0; i < length; i++) {
        switch (str[i]) {
            case '(' : ++lnum; break;
            case ')' : --lnum; break;
            default : return 0;
        }
        if (lnum >= 0) continue;
        return 0;
    }
    return lnum == 0;
}

我们可以把👆这个简化后的程序看作：遇到’(’，记录下来；遇到’)’，与最近的’('匹配，清除记录。也就是👇

堆栈-最终方案

1. 我们遍历整个数组
2. 如果遇到左括号’(’ ，’[’ ，’{’ ，就入栈。
3. 遇到右括号’)’ ，’]’ ，’}’ ，就与栈顶元素进行比较，如果匹配，就出栈。
4. 最后一个括号处理完成时，如果堆栈空，就合法(valid)；否则，不合法(invalid)

typedef struct Stack {
    char *val;
    int top, size; //记录堆栈栈顶的top，栈顶元素的上一个空位置，初始化为0
}Stack;

int isValid(char* str) {
    int len = strlen(str);
    Stack *s = init(len);
    for (int i = 0; i < len; i++) {
        switch (str[i]) {
            case '(' :
            case '[' :
            case '{' :
                push(s, str[i]); break;
            case ')' :
                if(isEmpty(s)) return 0;
                if(seek(s) != '(') return 0; pop(s); break;
            case '}' :
                if(isEmpty(s)) return 0;
                if(seek(s) != '{') return 0; pop(s); break;
            case ']' :
                if(isEmpty(s)) return 0;
                if(seek(s) != '[') return 0; pop(s); break;
        }
    }
    return isEmpty(s);
}

int isEmpty(Stack *s) {
    return !(s->top);
}

void push(Stack *s, char c) {
    s->val[s->top++] = c;
    return;
}

void pop(Stack *s) {
    s->top--;
    return ;
}

char seek(Stack *s) {
    return s->val[s->top - 1];
}

ps: 递归调用也可以

1. 我们也可以通过递归的方式调用系统栈，来实现。
2. 我们遍历整个字符串，遇到左括号，就递归，进入对下一个字符的判断
3. 遇到右括号或其他符号就返回上一层级，判断和上一层级的左括号是否匹配，完成判断后继续进行对下一个字符的判断。
4. 主要函数 bool judge(char *s, int *i, int d)中的参数，是bool judge(字符串, 需判断的字符下标, 递归层级)；其中整形变量d也可以看作，还有d个左括号没有被匹配。

bool isValid(char *str) {
    int i = 0;
    bool flag = judge(str, &i, 0);;
    return flag;
}

bool judge(char *str, int *i, int degree) {
    bool flag = true;
    
    /* while循环中两个判断，判断当前字符不为'\0'时遍历，flag为true时执行遍历。
    s[*i]保障最后的'\0'不进如字符判断，不对结果产生影响；
    flag保证当已经不合法时，不做没必要的运算，直接全部返回。*/
    
    while(str[*i] && flag) {
        switch (str[*i]) {
            case '(':
                (*i)++;
                flag = judge(str, i, degree + 1);
                flag && (str[*i] == ')' ? (*i)++,(flag=true) : (flag=false));
                break;
            case '[':
                (*i)++;
                flag = judge(str, i, degree + 1);
                flag && (str[*i] == ']' ? (*i)++,(flag=true) : (flag=false));
                break;
            case '{':
                (*i)++;
                flag = judge(str, i, degree + 1);
                flag && (str[*i] == '}' ? (*i)++,(flag=true) : (flag=false));
                break;
            case ')':
            case ']':
            case '}':
                return degree == 0 ? false : true;//当递归层级为0时，首先出现右括号，则必然没有左括号和它匹配。
            default :
                return false;
        }
    }
    return flag;
}