用栈2步轻松搞定【有效括号判断】。

1.思路

题目要求，字符串：仅包含：'(',')','{','}','['和']'。因此可以通过栈完成括号的匹配。

alt 如果文字描述的不太清楚，你可以参考视频的详细讲解：B站@好易学数据结构

2.代码

2.1 Python代码

#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
#
# @param s string字符串
# @return bool布尔型
#
class Solution:
    # 1. 定义一个栈
    def __init__(self):
        self.stack = []

    """
            栈相关操作:
    """

    def push(self, v):
        self.stack = [v] + self.stack

    def pop(self):
        self.stack = self.stack[1:]

    def top(self):
        return self.stack[0]

    def is_empty(self):
        if len(self.stack) == 0:
            return True
        return False

    def isValid(self, s: str) -> bool:
        # write code here
        for v in s:
            # 2. 如果是([{  ，则将对应的  )]}  入栈
            if v == "(":
                self.push(")")
            elif v == "[":
                self.push("]")
            elif v == "{":
                self.push("}")
            else:
                # 3. 字符为右括号，则进行匹配检查
                # 3.1 栈为空且字符串没有遍历完，如：))
                if self.is_empty():
                    return False
                # 3.2 字符串内容与栈顶元素不一致，则不匹配，如：(]
                if v != self.top():
                    return False
                # 3.3 每正确匹配一个，出栈一个元素，进行一下对括号的匹配
                self.pop()
        # 4. 所有字符串匹配完，且栈中没有元素，则说明括号匹配
        if self.is_empty():
            return True
        # 5. 所有字符串匹配完，栈中还有元素，则证明不匹配。如：()[
        return False

2.2 Java代码

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param s string字符串
     * @return bool布尔型
     */
    public boolean isValid (String s) {
        // write code here
        //1. 定义一个栈
        Stack<Character> stack = new Stack<>();
        for (int i = 0; i < s.length(); i++) {
            //2. 如果是( [ {  ，则将对应的  )  ]  }  入栈
            if (s.charAt(i) == '(') {
                stack.push(')');
            } else if (s.charAt(i) == '[') {
                stack.push(']');
            } else if (s.charAt(i) == '{') {
                stack.push('}');
            } else {
                //3. 字符为右括号，则进行匹配检查
                //3.1 栈为空且字符串没有遍历完，如：))
                if (stack.isEmpty()) {
                    return false;
                }
                //3.2 字符串内容与栈顶元素不一致，则不匹配，如：(]
                if (s.charAt(i) != stack.peek()) {
                    return false;
                }
                //3.3 每正确匹配一个，出栈一个元素，进行一下对括号的匹配
                stack.pop();
            }
        }
        // 4. 所有字符串匹配完，且栈中没有元素，则说明括号匹配
        if (stack.isEmpty()) {
            return true;
        }
        //5. 所有字符串匹配完，栈中还有元素，则证明不匹配。如：()[
        return false;
    }
}

2.3 Go代码

package main



/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 *
 * @param s string字符串
 * @return bool布尔型
 */
func isValid(s string) bool {
	// write code here
	//1. 定义一个栈
	stack = make([]uint8, 0)
	for i := 0; i < len(s); i++ {
		//2. 如果是( [ {  ，则将对应的  )  ]  }  入栈
		if s[i] == '(' {
			push(')')
		} else if s[i] == '[' {
			push(']')
		} else if s[i] == '{' {
			push('}')
		} else {
			//3. 字符为右括号，则进行匹配检查
			//3.1 栈为空且字符串没有遍历完，如：))
			if isEmpty() {
				return false
			}
			//3.2 字符串内容与栈顶元素不一致，则不匹配，如：(]
			if s[i] != top() {
				return false
			}
			//3.3 每正确匹配一个，出栈一个元素，进行一下对括号的匹配
			pop()
		}
	}
	if isEmpty() {
		// 4. 所有字符串匹配完，且栈中没有元素，则说明括号匹配
		return true
	}
	//5. 所有字符串匹配完，栈中还有元素，则证明不匹配。如：()[
	return false
}

var stack []uint8

// 栈相关操作:
func push(v uint8) {
	stack = append([]uint8{v}, stack...)
}
func pop() {
	stack = stack[1:]
}
func top() uint8 {
	return stack[0]
}
func isEmpty() bool {
	if len(stack) <= 0 {
		return true
	}
	return false
}

如果上面的代码理解的不是很清楚，你可以参考视频的详细讲解：B站@好易学数据结构