Aplicar algorítmo em Java

Posta o código que ta dando erro pq daí fica mais fácil…

Cheguei nesse ponto e parei...Nem eu vejo sentido no que digitei.

import javax.swing.JOptionPane;

public class Play {

	
	public static void main(String[] args) {
		
		Expressao pilha = new Expressao(30);
					
			String expr = JOptionPane.showInputDialog("Digite uma expressao algébrica no formato {[()]}");
			for(int i=0;i<expr.length();i++)
				pilha.empilha(expr.charAt(i));

public class Expressao {
	private Object elementos[];
	private int topo;
	private boolean valido = true;
	
	public Expressao(int tamanho){
		topo = -1;
		elementos = new Object[tamanho];
	}
	
	public void empilha(Object x){
		topo++;
		elementos[topo] = x;
	}
	
	public void desempilha(){
		topo--;
	}
	
	public Object elementoTopo(){
		return elementos[topo];
	}
	
	public boolean pilhaCheia(){
		return(topo == elementos.length - 1);
	}
	
	public int getTamanho(){
		return elementos.length;
	}
	
	public boolean listaVazia(){
		return(topo == -1);
	}
	
	public int getTopo(){
		return topo;
	}
	
	public Object getValor(int pos){
		return elementos[pos];
	}
}

Pelo q vc postou , coloco a minha resposta encontrada.

import javax.swing.*;

public class teste {

    public static void main(String[] args) {

        Expressao pilha = new Expressao(6);

        String expr = JOptionPane.showInputDialog("Digite uma expressão algébrica no formato {[()]}");

        for (int i = 0; i <= expr.length() - 1; i++) {

            if (pilha.getDelimitador(expr.charAt(i))) {
                pilha.empilha(expr.charAt(i));
            }
        }

        String aux = pilha.retornaFormato();

        if (aux.equals("{[()]}")) {
            System.out.println("Expressão Correta");
        } else {
            System.out.println("Expressão Incorreta");
        }

    }
}

class Expressao {

    protected String elementos[];
    private int topo;
    protected char[] delimitadores = {'{', '[', '(', ')', ']', '}'};

    public Expressao(int tamanho) {
        topo = -1;
        elementos = new String[tamanho];
    }

    public void empilha(char x) {
        topo++;
        elementos[topo] = String.valueOf(x);
    }

    public void desempilha() {
        topo--;
    }

    public String elementoTopo() {
        return elementos[topo].toString();
    }

    public boolean pilhaCheia() {
        return (topo == elementos.length - 1);
    }

    public boolean listaVazia() {
        return (topo == -1);
    }

    public boolean getDelimitador(char valor) {
        boolean ok = false;

        for (int i = 0; i <= delimitadores.length - 1; i++) {
            ok = delimitadores[i] == valor ? true : false;
            if (ok) {
                break;
            }
        }
        return ok;
    }

    public String retornaFormato(){

        String formato = "";
        for (int i = 0; i <= elementos.length-1; i++) {
              formato += elementos[i];             
          }

        return formato;
    }
}

Cara, eu acho que misturar assim fica meio confuso… seria mais facil se voce utilizasse alguma classe Stack que já está implementada no Java (vide Stack - Java 6 )

Se, por algum motivo (professor/curso/interesse) voce tenha que implementar uma pilha, faça isso separado também, tipo uma classe Pilha que apenas faz as funções da pilha (empilha(x), desempilha(), estaCheia(), verTopo() {retorna o valor do topo sem desempilhar, quantidadeElementos() e assim vai, de acordo com sua necessidade)

E a classe Expressao vai ter uma Pilha, e os métodos para validar/testar/manipular a expressão

Outra coisa é definir o que classifica uma expressão como válida, tipo, pode conter incógnitas? ou só podem ter operadores e números? dependendo do caso a validação será diferente…

Na minha opinião, uma validação seria primeiro verificar se o “aninhamento” está correto, tipo assim abre um colchete e depois um parêntesis, então tem que fechar o parêntesis e depois o colchete… Para isso, eu faria 2 vetores, um com caracteres de abertura e um com os de fechamento, daí voce percorre a expressão e toda vez que encontrar uma abertura voce a empilha, e toda vez que encontrar um de fechamento desempilha e compara ( o fechamento deve ser correspondente a abertura do topo da pilha )
Depois de verificado o aninhamento, verifica se os operadores ( ±*/^ ) estão corretos, tipo, cada operador deve estar entre duas expressões ( números ou blocos de parêntesis, colchetes etc )

drigo.angelo:

Se, por algum motivo (professor/curso/interesse) voce tenha que implementar uma pilha, faça isso separado também, tipo uma classe Pilha que apenas faz as funções da pilha (empilha(x), desempilha(), estaCheia(), verTopo() {retorna o valor do topo sem desempilhar, quantidadeElementos() e assim vai, de acordo com sua necessidade)

E a classe Expressao vai ter uma Pilha, e os métodos para validar/testar/manipular a expressão :P

você poderia dar um exemplo prático de como fazer a pilha no codigo acima?

drigo.angelo:

Para isso, eu faria 2 vetores, um com caracteres de abertura e um com os de fechamento, daí voce percorre a expressão e toda vez que encontrar uma abertura voce a empilha, e toda vez que encontrar um de fechamento desempilha e compara ( o fechamento deve ser correspondente a abertura do topo da pilha )
Depois de verificado o aninhamento, verifica se os operadores ( ±*/^ ) estão corretos, tipo, cada operador deve estar entre duas expressões ( números ou blocos de parêntesis, colchetes etc )

Eu consegui entender o raciocinio do que você descreve acima, mas não estou conseguindo colocar em prática, poderia dar uma ajuda e implementar isso no código?