ValidarPrefija.java

import java.util.Stack;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.swing.*;

public class ValidarPrefija {
    public static void main(String[] args) {
        // Crear la interfaz gráfica
        JFrame frame = new JFrame("Validador de Expresiones Prefijas");
        JTextField textField = new JTextField(20);
        JButton button = new JButton("Validar");
        JLabel label = new JLabel("Ingresa una expresión prefija:");

        frame.setLayout(new java.awt.FlowLayout());
        frame.add(label);
        frame.add(textField);
        frame.add(button);

        // Acción del botón
        button.addActionListener(e -> {
            String input = textField.getText().trim();
            if (esPrefijaValida(input)) {
                JOptionPane.showMessageDialog(frame, "Expresión prefija válida.");
            } else {
                JOptionPane.showMessageDialog(frame, "Expresión prefija inválida.");
            }
        });

        frame.setSize(300, 150);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }

    // Método para validar la expresión prefija
    public static boolean esPrefijaValida(String exp) {
        // Verificar si los paréntesis están balanceados
        if (!paréntesisBalanceados(exp)) {
            return false;
        }

        // Pila para manejar los operandos
        Stack<Integer> stack = new Stack<>();

        // Separar la expresión en sus componentes (tokens)
        String[] tokens = separarTokens(exp);

        // Recorrer los tokens en orden inverso (para la notación prefija)
        for (int i = tokens.length - 1; i >= 0; i--) {
            String token = tokens[i];

            // Si el token es un número o una variable, lo apilamos
            if (esNumero(token) || esVariable(token)) {
                stack.push(1); // Apilamos un operando
            } else if ("+-*/".contains(token)) {
                // Si el token es un operador, necesitamos al menos dos operandos en la pila
                if (stack.size() < 2) {
                    return false;  // No hay suficientes operandos
                }
                // Aplicamos el operador (aunque no lo hacemos realmente)
                stack.pop();  // Primer operando
                stack.pop();  // Segundo operando
                stack.push(1); // Apilamos el resultado de la operación
            } else {
                // Si el token no es un número, una variable o un operador válido
                return false;
            }
        }

        // Al final, solo debe quedarnos un operando en la pila
        return stack.size() == 1;
    }

    // Método para verificar si los paréntesis están balanceados
    public static boolean paréntesisBalanceados(String exp) {
        Stack<Character> stack = new Stack<>();
        for (char c : exp.toCharArray()) {
            if (c == '(') {
                stack.push(c);  // Apilamos un paréntesis de apertura
            } else if (c == ')') {
                if (stack.isEmpty()) {
                    return false;  // Paréntesis de cierre sin apertura correspondiente
                }
                stack.pop();  // Eliminamos el paréntesis de apertura
            }
        }
        return stack.isEmpty();  // Si la pila está vacía, los paréntesis están balanceados
    }

    // Método para verificar si el token es un número
    public static boolean esNumero(String token) {
        try {
            Integer.parseInt(token);  // Intentar convertir el token a un número
            return true;
        } catch (NumberFormatException e) {
            return false;
        }
    }

    // Método para verificar si el token es una variable (letra)
    public static boolean esVariable(String token) {
        return token.matches("[a-zA-Z]");  // Comprobar si el token es una letra
    }

    // Método para separar la expresión en tokens (números, letras y operadores)
    public static String[] separarTokens(String input) {
        // Usar una expresión regular para separar números, letras y operadores
        Pattern pattern = Pattern.compile("[0-9]+|[a-zA-Z]+|[-+*/]");
        Matcher matcher = pattern.matcher(input);

        // Crear una lista de tokens encontrados
        StringBuilder sb = new StringBuilder();
        while (matcher.find()) {
            sb.append(matcher.group()).append(" ");
        }

        // Devolver los tokens separados en un arreglo
        return sb.toString().trim().split("\\s+");
    }
}