import java.util.Scanner; public class Arbol_Expresiones { private static class NodoArbol{ private final boolean hoja; // Es Hoja o interno??

private final char op; // Para un nodo interno, Operador private double val; // Para una hoja o valor private NodoArbol izq, // hijo izquierdo(sub espresion izquierda) der; // hijo derecho(sub espresion derecha) //Constructor private NodoArbol ( boolean hoja, char op, double val ){ this.hoja = hoja; this.op = op; this.val = val; this.izq = null; this.der = null; } //Para los nodos hoja se muestra el valor; interno(operador) public String toString(){ // Se sobrescrib Object.toString, debe ser publico. return hoja ? Double.toString(val) : Character.toString(op) ; } } NodoArbol raiz = null; public Arbol_Expresiones( Scanner entrada ){ raiz = Construir(entrada); } /** * Basado en una expresin delimitada por espacios en blanco prefijo, construir el * Binario correspondiente rbol de expresin. * @ Param entrada El escner con la expresin * @ Return referencia al rbol binario de expresin correspondiente */ private NodoArbol Construir( Scanner entrada ){ boolean hoj; String c; double val; NodoArbol nodo; hoj = entrada.hasNextDouble(); if (hoj){ val = entrada.nextDouble(); nodo = new NodoArbol(hoj, '\0', val); } else { c = entrada.next(); nodo = new NodoArbol(hoj, c.charAt(0),0.0); nodo.izq = Construir(entrada); nodo.der = Construir(entrada); } return nodo; } /** * Muestra el arbol de expresiones en posfijo. * Todo el trabajo se hace en el mtodo recursivo privado.

*/ public void muestraPosfijo(){ muestraPosfijo(raiz); System.out.println(); } // La expresion posfijo es el resultado de un recorrido en pos-orden. private void muestraPosfijo(NodoArbol nodo){ if ( nodo != null ){ muestraPosfijo ( nodo.izq ); muestraPosfijo ( nodo.der ); System.out.print ( nodo + " " ); } } /** * Muestra el arbol de expresiones en prefijo. * Todo el trabajo se hace en el metodo recursivo privado. */ public void muestraPrefijo(){ muestraPrefijo(raiz); System.out.println(); } // La expresion prefijo es el resultado de un recorrido en pre-orden private void muestraPrefijo(NodoArbol nodo){ // Nota: Se elemino la recurcion while(nodo != null){ System.out.print ( nodo + " " ); muestraPrefijo ( nodo.izq ); nodo = nodo.der; // parametro de actualizacion para el recorrido } } /** * Muestra el arbol de expresiones en infijo. * Todo el trabajo de hace en el metodo recursivo privado. */ public void muestraInfijo(){ muestraInfijo ( raiz ); System.out.println(); } /*La expresin en infijo requiere parentesis asi como en posfijo y en prefijo, * ademas del nodo que esta en in-orden.*/ private void muestraInfijo(NodoArbol nodo){ if ( nodo != null ){ // Nota: No poner entre parentesis los nodos hoja if (!nodo.hoja) System.out.print("( "); // Pre-orden muestraInfijo (nodo.izq); System.out.print (nodo + " "); // In-orden muestraInfijo ( nodo.der ); if (!nodo.hoja) // Pos-orden System.out.print (") "); } } /** * Evalua la expresion y devuelve su valor

* El trabajo lo hace el metodo recursivo privado. * @return el valor de la expresion del arbol. */ public double evaluate(){ return raiz == null ? 0.0 : evaluate (raiz) ; } /** Evalua la expresion: nodos internos, esto equivale * a un recorrido en pos-orden, el el procesamiento se realiza * la aritmetica. Para los nodos hoja, es simplemente el valor del nodo. */ private double evaluate(NodoArbol nodo){ double result; // regresa el valor if(nodo.hoja) // solo obtiene el valor de la hoja result = nodo.val; else{ //Comenzamos con la evaluacion de la expresion double izq, der; char operador = nodo.op; // Se campturan los valores de las sub-expresiones izq y der izq = evaluate(nodo.izq); der = evaluate(nodo.der); //Realizamos aritmetica, basados en el operador switch ( operador ){ case '-': result = izq - der; break; case '*': result = izq * der; break; case '/': result = izq / der; break; case '^': result = Math.pow (izq, der); break; //Nota: interpreta + en caso de error. default: System.out.println ("Operador desconocido " +operador+ " entendido como +."); case '+': result = izq + der; break; } } // Se regresa el valor recien calculado. return result; } } //////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////// /* CLASE PRUEBA EXPRESION */ import java.util.Scanner; import javax.swing.AbstractAction.*; import javax.swing.JOptionPane; public class PruebaExpresion { public static void main (String args[] ){ String cad1= "+ 1 * 2 3"; String cad2= "+ 1 * 2 8 4"; Scanner s = new Scanner(cad1); Scanner s2 = new Scanner(cad2); Arbol_Expresiones exp = new Arbol_Expresiones(s); Arbol_Expresiones exp2 = new Arbol_Expresiones(s2); System.out.println("Expresion 1 PosFija"); exp.muestraPosfijo(); System.out.println("Expresion 1 PreFija");

exp.muestraPrefijo(); System.out.println("Expresion 1 InFija"); exp.muestraInfijo(); double res = exp.evaluate(); System.out.println("Resultado 1: " + res); System.out.println("__________________________________________"); System.out.println("Expresion 2 PosFija"); exp2.muestraPosfijo(); System.out.println("Expresion 2 PreFija"); exp2.muestraPrefijo(); System.out.println("Expresion 2 InFija"); exp.muestraInfijo(); double res2 = exp2.evaluate(); System.out.println("Resultado 2: " + res2); } } --------------------------------------------------------------------------------------------------------------------------------------------------------------

import java.util.*; /** * Clase para generar arboles binarios a partir de expresiones aritmeticas * @author Amparo Lpez Gaona * @version 1a. ed. */ public class ArbolExpresiones { Pila pOperandos; // Pila de operandos Pila pOperadores; // Pila de operadores final String blanco; // Cadena de espacios en blanco final String operadores; // Cadena con operadores para expresiones /** * Constructor por omision */ public ArbolExpresiones() { pOperandos = new Pila(); pOperadores = new Pila(); blanco = " \t"; operadores = ")+-*/%^("; //acomodados por precedencia; } /**

* Metodo para construir un arbol para una expresion aritmetica dada. * @param expresion -- Cadena con la expresion aritmetica * @return NodoArbol -- nodo raiz del arbol creado */ public NodoArbol construirArbol(String expresion) { StringTokenizer tokenizer; String token; NodoArbol raiz = null; tokenizer = new StringTokenizer(expresion, blanco+operadores, true); while (tokenizer.hasMoreTokens()) { token = tokenizer.nextToken(); if (blanco.indexOf(token) >= 0) ; // Es un espacio en blanco, se ignora else if (operadores.indexOf(token) < 0) { // Es operando y lo guarda como nodo del arbol pOperandos.push(new NodoArbol(token)); } else if(token.equals(")")) { // Saca elementos hasta encontrar ( while (!pOperadores.estaVacia() && !pOperadores.top().equals("(" )) { guardarSubArbol(); } pOperadores.pop(); // Saca el parentesis izquierdo } else { if (!token.equals("(") && !pOperadores.estaVacia()) { //operador diferente de cualquier parentesis String op = (String) pOperadores.top(); while (!op.equals("(") && !pOperadores.estaVacia() && operadores.indexOf(op) >= operadores.indexOf(token )) { guardarSubArbol(); if (!pOperadores.estaVacia()) op = (String)pOperadores.top(); } } pOperadores.push(token); //Guarda el operador } } //Sacar todo lo que queda raiz = (NodoArbol)pOperandos.top(); while (!pOperadores.estaVacia()) { if (pOperadores.top().equals("(")) { pOperadores.pop(); } else { guardarSubArbol(); raiz = (NodoArbol) pOperandos.top(); } } return raiz; } /* * Metodo privado para almacenar en la pila un subarbol */ private void guardarSubArbol() { NodoArbol op2 = (NodoArbol)pOperandos.pop(); NodoArbol op1 = (NodoArbol)pOperandos.pop(); pOperandos.push(new NodoArbol(op1, pOperadores.pop(), op2)); }

/** * Metodo para imprimir un arbol en inorden * @param n -- nodo raiz */ public void imprime(NodoArbol n) { if (n != null) { imprime(n.izquierda); System.out.print(n.valor+" "); imprime(n.derecha); } } /** * Metodo para imprimir un arbol en postorden * @param n -- nodo raiz */ public void imprimePos(NodoArbol n) { if (n != null) { imprimePos(n.izquierda); imprimePos(n.derecha); System.out.print(n.valor+" "); } } /** * Metodo para imprimir un arbol en preorden * @param n -- nodo raiz */ public void imprimePre(NodoArbol n) { if (n != null) { System.out.print(n.valor+" "); imprimePre(n.izquierda); imprimePre(n.derecha); } } public static void main (String[] pps) { ArbolExpresiones expr = new ArbolExpresiones(); if (pps.length < 1) System.out.println("Debe ejecutarse: ArbolExp \"expresion con espaci os y parentesis\" "); else for (int i = 0; i < pps.length; i++) { NodoArbol raiz = expr.construirArbol(pps[i]); System.out.print("El arbol es "); expr.imprime(raiz); System.out.print("\nEl arbol en postfija es "); expr.imprimePos(raiz); // System.out.println("\n"); System.out.print("\nEl arbol en prefija es "); expr.imprimePre(raiz); System.out.println("\n\n"); } } }