20_有效的括號（Valid-Parentheses）

文章目錄

• 20_有效的括號（Valid-Parentheses）
• 描述
• 解法
• 思路
• Java 實現
• Python 實現
• 複雜度分析

描述

給定一個只包括 '('，')'，'{'，'}'，'['，']' 的字串，判斷字串是否有效。

有效字串需滿足：

1. 左括號必須用相同型別的右括號閉合。
2. 左括號必須以正確的順序閉合。

注意空字串可被認為是有效字串。

示例 1:

輸入: "()"
輸出: true
 

示例 2:

輸入: "()[]{}"
輸出: true

示例 3:

輸入: "(]"
輸出: false

示例 4:

輸入: "([)]"
輸出: false

示例 5:

輸入: "{[]}"
輸出: true

解法

思路

遍歷字串的每個字元，如果字元是左半邊的括號（即 (、[ 或者{），將字元壓入棧；如果字元是右半邊括號（即 )、] 或者 }），此時首先判斷堆疊是否為空，如果棧為空，則該字元無法找到匹配的括號，返回 false，如果棧不為空，則彈出棧頂元素並與之比較，如果兩個字元不相同，同樣返回 false。最後，遍歷完整個字串後，還需要判斷堆疊是否為空，如果為空，則是有效的括號，反之則為無效的括號。

Java 實現

class Solution {
    public boolean isValid(String s) {
        Stack<Character> stack = new Stack<>();
        for (int i=0; i<s.length(); i++) {
            char c = s.charAt(i);

            if (c == '(' || c == '[' || c == '{') {
                stack.push(c);
            }
 
 else {
                if (stack.empty()) {
                    return false;
                }

                char topChar = stack.pop();
                if (c == ')' && topChar != '(') {
                    return false;
                }
                if (c == ']' && topChar != '[') {
                    return false;
                }
                if (c == '}' && topChar != '{') {
                    return false;
                }
            }
        }

        return stack.isEmpty();
    }
}

改進版：

class Solution {
    public boolean isValid(String s) {
        Stack<Character> stack = new Stack<>();
        for (char c : s.toCharArray()) {
            if (c == '(') {
                stack.push(')');
            } else if (c == '[') {
                stack.push(']');
            } else if (c == '{') {
                stack.push('}');
            } else if (stack.isEmpty() || c != stack.pop()) {
                return false;
            }
        }
        return stack.isEmpty();
    }
}

Python 實現

實現1：

class Solution:
    def isValid(self, s):
        """
        :type s: str
        :rtype: bool
        """
        stack = list()
        for si in s:
            if si == '(':
                stack.append(')')
            elif si == '[':
                stack.append(']')
            elif si == '{':
                stack.append('}')
            elif len(stack) == 0 or si != stack.pop():
                return False
        return len(stack) == 0

實現 2（藉助字典）：

class Solution:
    def isValid(self, s):
        """
        :type s: str
        :rtype: bool
        """
        stack = list()
        dict = {'(': ')', '[': ']', '{': '}'}
        for c in s:
            if c in dict.keys():
                stack.append(dict[c])
            elif c in dict.values():
                if len(stack) == 0 or c != stack.pop():
                    return False
            else:
                False
        return len(stack) == 0

複雜度分析

• 時間複雜度： $O(n)$，其中 $n$ 表示字串的長度
• 空間複雜度： $O(n)$，最壞的情況下，堆疊需要存放字串的所有字元