力扣 [20] [简单] [有效的括号]

20. 有效的括号

难度简单2528收藏分享切换为英文接收动态反馈

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

1. 左括号必须用相同类型的右括号闭合。
2. 左括号必须以正确的顺序闭合。

示例 1：

输入：s = "()"
输出：true

示例 2：

输入：s = "()[]{}"
输出：true

示例 3：

输入：s = "(]"
输出：false

示例 4：

输入：s = "([)]"
输出：false

示例 5：

输入：s = "{[]}"
输出：true

提示：

• 1 <= s.length <= 104
• s 仅由括号 '()[]{}' 组成

---------------------------------------分割线------------------------------------------------

看到这种题左右括号的题，先看题目是问是否能完全匹配，还是让我们把所有情况列举出来。

1. 如果只是问是否匹配，直接用栈的思想做就行。

2. 如果是罗列所有组合，用回溯法的思想。

这题是问是否匹配，用栈来做，思路就是，遇到左括号就入栈，遇到右括号就出栈，然后与右括号比较，看是否匹配，一直到字符串最后，如果比完了栈还有元素，那就是不匹配。

顺便复习一下栈，下面是两种方式，第一种是比较完整详细的栈操作，第二种比较简单栈操作。

【第一种】

typedef struct{
    char*arr;
    int top;
    int maxsize;
}STACK;

int stack_init(STACK*st, int arr_size) {
    if (st == NULL) {
        return -1;
    }
    st->arr = (STACK*)malloc(sizeof(char)*arr_size);
    if (st->arr == NULL) {
        return -1;
    }
    st->top =-1;
    st->maxsize = arr_size;
    return 0;
}

void stack_deinit(STACK*st) {
    if (st != NULL) {
        if (st->arr != NULL) {
            free(st->arr);
        }
        st->top=-1;
        st->maxsize=0;
    }
}

bool is_stack_full(STACK*st) {
    if(st == NULL) {
        //用户保证传进来的stack已创建，空指针则认为满，限制压栈
        return true;
    } 
    return (st->top == (st->maxsize-1));
}

bool is_stack_empty(STACK*st) {
    if(st == NULL) {
        //用户保证传进来的stack已创建，空指针则认为空，限制出栈
        return true;
    } 
    return (st->top == -1);
}

int stack_push(STACK*st, char val) {
    if (st == NULL) {
        return -1;
    } 
    if (!is_stack_full(st)) {
        st->arr[++st->top] = val;
        return 0;
    } 
    return -1;
}

int stack_pop(STACK*st, char *val) {
    if (st == NULL) {
        return -1;
    } 
    if (!is_stack_empty(st)) {
        (*val) = st->arr[st->top--];
        return 0;
    } 
    return -1;   
}

bool is_match(char c1, char c2) {
    bool ret = false;
    switch (c1) {
        case '(':
            ret = (c2==')')?true:false;
            break;
        case '[':
            ret = (c2==']')?true:false;
            break;
        case '{':
            ret = (c2=='}')?true:false;
            break;
        default:
            ret = false;
            break;
    }
    return ret;
}

bool isValid(char * s) {
    STACK st;
    int slen = 0;
    char *p = s;
    char val = 0;

    if (s==NULL) {
        return false;
    }

    memset(&st, 0, sizeof(STACK));

    slen = strlen(s);
    if (stack_init(&st, slen)) {
        printf("stack_init FAILED\n");
        return false;
    }

    while (*p != '\0') {
        if ((*p=='(') || (*p=='[') || (*p=='{')) {
            stack_push(&st, *p);
        } else {
            //出栈失败，认为栈空,直接返回错误
            if (stack_pop(&st, &val)) {
                return false;
            }
            if (!is_match(val, *p)) {
                return false;
            }
        }
        p++;
    }
    if (st.top!=-1) {
        return false;
    }
    stack_deinit(&st);
    return true;
}

【第二种】

bool match(char a, char b){
    if(((a=='(')&&(b==')'))
        ||((a=='[')&&(b==']'))
        ||((a=='{')&&(b=='}'))) {
        return true;
    } 
    return false;
}

bool isValid(char * s){
    int i,j,k;
    int top=-1;
    char *p = s;
    char *array = NULL;
    char tmp;
    int slen = strlen(s);

    //非标准，简单栈写法(可以优化，goto异常跳转，释放内存退出)
    array = (char *)malloc(slen);

    while (*p!='\0') {
        if ((*p=='(')||(*p=='[')||(*p=='{')) {
            //1. 不判断满，直接入栈。(因为字符串大小能知道)
            array[++top] = *p;
        } else {
            if(top>=0){
                //2. 题目说输入只有左右括号，获取到右括号的时候，出栈一个元素，与字符串的元素对比，匹配则进行下一个字符。不匹配则返回false
                tmp = array[top--];
                if (!match(tmp, *p)) {
                    free(array);
                    return false;
                }
            } else {
                //3. top<0时，说明没有左括号，此时强行出站可能踩内存。表示输入为只有右括号，直接返回错误不匹配即可
                free(array);
                return false;
            }
        }
        p++;
    }
    //4. 最终出栈时如果没有残留，表明完全匹配，返回true
    if (top==-1) {
        free(array);
        return true;
    }
    free(array);
    return false;
}