Programa Java para verificar paréntesis equilibrados en una expresión (buena formación) usando Stack

Dada una string de expresión exp, escriba un programa para examinar si los pares y los órdenes de “{“, “}”, “(“, “)”, “[“, “]” son correctos en exp.

Ejemplo

Entrada : exp = “[()]{}{[()()]()}” 
Salida : Balanceada

Entrada : exp = “[(])” 
Salida : No balanceada 

check-for-balanced-parentheses-in-an-expression

Algoritmo: 

  • Declara una pila de caracteres S.
  • Ahora recorra la string de expresión exp. 
    1. Si el carácter actual es un corchete de inicio ( ‘(‘ o ‘{‘ o ‘[‘ ) entonces empújelo para apilar.
    2. Si el carácter actual es un corchete de cierre ( ‘)’ o ‘}’ o ‘]’ ), entonces salte de la pila y si el carácter reventado es el corchete de inicio correspondiente, entonces bien, de lo contrario, los corchetes no están equilibrados.
  • Después de completar el recorrido, si queda algún soporte inicial en la pila, entonces «no está equilibrado»

La imagen de abajo es una ejecución en seco del enfoque anterior:

A continuación se muestra la implementación del enfoque anterior:

Java

// Java program for checking
// balanced brackets
import java.util.*;
  
public class BalancedBrackets {
  
    // function to check if brackets are balanced
    static boolean areBracketsBalanced(String expr)
    {
        // Using ArrayDeque is faster than using Stack class
        Deque<Character> stack
            = new ArrayDeque<Character>();
  
        // Traversing the Expression
        for (int i = 0; i < expr.length(); i++) 
        {
            char x = expr.charAt(i);
  
            if (x == '(' || x == '[' || x == '{') 
            {
                // Push the element in the stack
                stack.push(x);
                continue;
            }
  
            // If current character is not opening
            // bracket, then it must be closing. So stack
            // cannot be empty at this point.
            if (stack.isEmpty())
                return false;
            char check;
            switch (x) {
            case ')':
                check = stack.pop();
                if (check == '{' || check == '[')
                    return false;
                break;
  
            case '}':
                check = stack.pop();
                if (check == '(' || check == '[')
                    return false;
                break;
  
            case ']':
                check = stack.pop();
                if (check == '(' || check == '{')
                    return false;
                break;
            }
        }
  
        // Check Empty Stack
        return (stack.isEmpty());
    }
  
    // Driver code
    public static void main(String[] args)
    {
        String expr = "([{}])";
  
        // Function call
        if (areBracketsBalanced(expr))
            System.out.println("Balanced ");
        else
            System.out.println("Not Balanced ");
    }
}
Producción

Balanced

Complejidad de Tiempo: O(n) 
Espacio Auxiliar: O(n) para pila. 

¡Consulte el artículo completo sobre Verificación de paréntesis equilibrados en una expresión (bien formado) usando Stack para obtener más detalles!

Publicación traducida automáticamente

Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *