Deber#3

Crear un método que verifique si una expresión tiene correctamente definidos los paréntesis.

1. Creamos una variable llamada pila para guardar nuestra expresión ingresada por teclado.
2.  La variable i la utilizaremos como contador
3. Aplicamos la expresión while para recorrer toda la expresión y saldrá cuando i sea igual al tamaño de la expresión ingresada por teclado.
4. Utilizaremos if para comparar si existe el paréntesis de apertura "(". Si es cierto lo ingresamos a la pila con push, caso contrario verificaremos si el paréntesis es de cierre ")". Si es cierto de nuevo verificará si la pila no está vacía, si es cierto elimina el ultimo valor ingresado en la pila caso contrario ingresaremos ")". Terminará hasta verificar toda la expresión.
5. En el último if pregunta si la pila está vacía en caso de ser cierto retorna true caso contrario retorna false.

Crear un método que convierta una expresión en notación in-fix a post-fix

1.  Hacermos for para poder ir recorriendo nuestra expresión caracter por caracter y ése se guardará en la variable "ch".
2. Dependiendo del caso usamos un switch.
3. Si "ch" es + o - va al método gotOper que mandamos como parámetro el carácter y la prioridad de + o - es 1.
4. Si "ch" es * o / va al método gotOper que mandamos como parámetro el carácter y la prioridad de * o / es 2.
5.  Si "ch" es ^ va al método gotOper que mandamos como parámetro el carácter y la prioridad de * o / es 3.
6. Si "ch" es "(" lo agregamos a la pila theStack.
7. Si "ch" es ")" va al método gotParen que manda como parámetro "ch"
8. En default: Si el carácter no es un operados se lo agregará a nuestra variable String output
9. Después del for entramos a un while que entra cuando la pila no está vacía agregaremos cada carácter a nuestro String output hasta que la pila quede vacía.
10. El paso 8 se refiere que luego de recorrer toda la expresion con la ayuda de for ya no queda operadores al cual comparar con la pila y entonces no más lo agrega esos valores a output. Al final imprime y retorna la la variable output.

 El método gotOper:
1. Al inicio siempre la pila va a estar vacía entonces agrega ese operador en la pila.
2. Cuando no esté vacía va a entrar al while.
3. La cima de la pila es quitado y es agregado a nuestra variable opTop.
4. Si opTop es '(' se lo agrega a la pila sale del while y agrega el el valor del carácter opThis.
5. Caso contrario dependiendo si opTop es +, -, *, / y ^

+, - tiene  prec1=1. => prec2=1

*, / tiene prec1=2. => prec2=2

^ tiene prec1=3. => prec2=3 

 El método gotParen(ch)
1. Recibe el parámetro ch.
2. Si la pila no está vacía entra al while.
3. Quita el valor de la cima de la pila y lo agrega a chx
4. Si chx='(' sale del while
5. Caso contrario lo agrega a la variable output.

Crear un método que evalué una expresión en postfix

1. Mandamos como parámetro lo valores de la variable y la expresión.
2. Con la ayuda de for recorreremos toda la expresion1 y guardaremos a nuestra variable temporal ch carácter por carácter.
3. Si j es menor al tamaño de la lista variables entra al if y con nuestra variable temporal v le añadiremos el nombre de la variable y su valor.
4. Si v.mombre == a ch entonces entra al if y tomamos el valor de esa variable y lo agregaremos a la pila.
5. Caso contrario ya al tener nuestras dos variables realizará dicha operación.
6. En caso de que la expresion esté mal saldrá lo descrito en default.