力扣第20题：有效的括号（×）不用堆栈的消消乐！（√）

fortune+

于 2023-09-10 16:55:43 发布

阅读量161

点赞数

文章标签： leetcode 算法 c语言

本文链接：https://blog.csdn.net/m0_74102727/article/details/132791118

版权

大家好，我又来互联网上随地乱丢赛博垃圾了，还望拨冗批评扶正o.o

题目：

当我不了解什么堆什么栈时，选择使用最纯粹的力量

力扣官方题解：

总结

题目：

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

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
每个右括号都有一个对应的相同类型的左括号。

示例 1：

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

示例 2：

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

示例 3：

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

提示：

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

个人感觉题目描述并不十分清晰，下面做一些个人补充：

1.你的代码需要通过 return 返回 false 或是 true，而不是 printf("false");

2.不要使用 sizeof 判断数组长度，因为数组传址后，sizeof(s) 得到的是 8 （64位情况下），这个数字是根据数组首地址得出的。

3.所有的右括号 ) } ] 必须紧邻对应的左括号才算符合题意。 ( [ ) ] 判定为 false。

当我不了解什么堆什么栈时，选择使用最纯粹的力量

使用消消乐的力量，通过是必然的。

思路：从头开始遍历数组，一旦找到右括号，就看上一个位置是不是正确的左括号。如果是正确的左括号，就将这两个位置都赋值为'0'，并继续遍历数组。如果上一个位置不是正确的左括号，就return false，如果上一个位置是'0'，证明这里是咱们消去过的位置，再往前找，直到找到非0位置进行判定。最后进行一个循环，判断修改后的字符串数组是不是全部为0，若全部为0，证明每一个右括号都有紧邻的对应左括号，结果为 true。

变量说明：i负责从头遍历一遍数组，j负责实现找到右括号后寻找上一位左括号。

bool isValid(char* s) {
    int num = strlen(s);
    if (num % 2 == 1) 
    {
        return false;
    }
    for (int i = 0, j = 1;i < strlen(s); i++)
    {
        j = 1;
        if (s[i] == ')')
        {
            if (i - j < 0)
            {
                return false;
            }
            while (s[i - j] == '0')
            {
                j++;
                if (i - j < 0)
                {
                    return false;
                }
            }
            if (s[i - j] == '(')
            {
                s[i - j] = '0';
                s[i] = '0';
            }
            else if (s[i - j] == '[' || s[i - j] == '{')
            {
                return false;
            }
        }
        else if (s[i] == '}')
        {
            if (i - j < 0)
            {
                return false;
            }
            while (s[i - j] == '0')
            {
                j++;
                if (i - j < 0)
                {
                    return false;
                }
            }
            if (s[i - j] == '{')
            {
                s[i - j] = '0';
                s[i] = '0';
            }
            else if (s[i - j] == '[' || s[i - j] == '(')
            {
                return false;
            }
        }
        else if (s[i] == ']')
        {
            if (i - j < 0)
            {
                return false;
            }
            while (s[i - j] == '0')
            {
                j++;
                if (i - j < 0)
                {
                    return false;
                    return 0;
                }
            }
            if (s[i - j] == '[')
            {
                s[i - j] = '0';
                s[i] = '0';
            }
            else if (s[i - j] == '{' || s[i - j] == '(')
            {
                return false;
                return 0;
            }
        }
    }
    for (int key = 0; key < strlen(s); key++)
    {
        if (s[key] != '0')
        {
            return false;
            return 0;
        }
    }
    return true;
}

复杂度分析：

时间复杂度：O(n^2)，因为存在两个循环嵌套。

空间复杂度：O(n)，因为有几个元素就要开辟多少空间。

力扣官方题解：

思路：官方首先创造了一个空字符数组，数组长度为原数组的长度 + 1。在原数组中从头开始遍历，寻找元素。如果是左括号，则放入新数组中，如果是右括号，则看新数组最新元素是否是对应的左括号。如果是，则消去，如果不是，则 return false。最后如果新数组长度变成了0，则 return true。

char pairs(char a) {
    if (a == '}') return '{';
    if (a == ']') return '[';
    if (a == ')') return '(';
    return 0;
}

bool isValid(char* s) {
    int n = strlen(s);
    if (n % 2 == 1) {
        return false;
    }
    int stk[n + 1], top = 0;
    for (int i = 0; i < n; i++) {
        char ch = pairs(s[i]);
        if (ch) {
            if (top == 0 || stk[top - 1] != ch) {
                return false;
            }
            top--;
        } else {
            stk[top++] = s[i];
        }
    }
    return top == 0;
}

复杂度分析

时间复杂度：O(n)，其中 n 是字符串 s 的长度。

空间复杂度：O(n)，其中 n 是字符串 s 的长度。（因为新开辟了一个长度为 n + 1 的数组）