Una pregunta de prueba escrita por día - leetCode: 20. Paréntesis válidos (simple)

Una prueba escrita al día –leetCode: 20. Paréntesis válidos (simple)

## leetCode: 20. Paréntesis válidos (simple)

Incluye solo un hecho '(', ')', '{', '}', '[', ']'cadena, determina si la cadena es válida.

Una cadena válida debe cumplir:

1. El paréntesis izquierdo debe cerrarse con el mismo tipo de paréntesis derecho.
2. El paréntesis de apertura debe cerrarse en el orden correcto.

Tenga en cuenta que una cadena vacía se puede considerar una cadena válida.

Ejemplo 1:

输入: "()"
输出: true

Ejemplo 2:

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

Ejemplo 3:

输入: "(]"
输出: false

Ejemplo 4:

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

Ejemplo 5:

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

Solución uno: apilar

Juzgar la validez de los paréntesis se puede resolver utilizando la estructura de datos "pila".

Atravesamos la cadena dada s , y cuando encontramos un paréntesis de apertura, esperamos que en el recorrido posterior, un paréntesis de cierre del mismo tipo lo cierre. Dado que el paréntesis izquierdo que se encuentra más adelante debe cerrarse primero , podemos poner este paréntesis izquierdo en la parte superior de la pila.

Cuando nos encontramos con un paréntesis de cierre, debemos cerrar un paréntesis de apertura del mismo tipo. En este punto, podemos sacar el paréntesis izquierdo en la parte superior de la pila y determinar si son del mismo tipo de paréntesis. Si no es del mismo tipo, o no hay paréntesis en la pila, entonces la cadena s no es válida y se devuelve False . Para determinar rápidamente el tipo de paréntesis, podemos usar HashMap para almacenar cada tipo de paréntesis. La clave del mapa hash es el paréntesis derecho y el valor es el mismo tipo de paréntesis izquierdo.

Una vez finalizado el recorrido, si no hay paréntesis en la pila, significa que cerramos todos los paréntesis izquierdos en la cadena sy devolvemos True ; de lo contrario, devolvemos False .

Tenga en cuenta que la longitud de una cadena válida debe ser un número par, por lo que si la longitud de la cadena es un número impar, podemos devolver directamente False para guardar el proceso de juicio transversal posterior.

   public boolean isValid(String s) {
    
    
              //获取字符串的长度
        int n = s.length();
        //如果字符串长度为奇数，则不可能有效，直接返回false
        if (n % 2==1) {
    
    
            return false;
        }

        //用哈希映射（HashMap）存储每一种括号。
        HashMap<Character, Character> pairs = new HashMap(){
    
    
            {
    
    
                put(')','(');
                put(']','[');
                put('}','{');
            }
        };

        //创建一个队列
        Deque<Character> stack=new LinkedList<>();

        for (int i = 0; i <n ; i++) {
    
    
            char c = s.charAt(i);
            if (pairs.containsKey(c)) {
    
    
                if (stack.isEmpty() || stack.peek() != pairs.get(c)) {
    
    
                    return false;
                }
            stack.pop();
            }else {
    
    
                stack.push(c);
            }
        }

        return stack.isEmpty();
    }

Solución dos:

    public boolean isValid(String s) {
    
    
        LinkedList<Character> stack = new LinkedList<>();
        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();
    }