hola amigos, buen dia. alguien me podria ayudar a modificar un codigo de infijo a postfijo con pilas. son 2 cosas que necesito hacer:
1.-ejemplo : Entrada : (100+5.75) + 100 -> salida : 100 5.75 + 100 +.
el problema es que solo acepta caracteres de 1 solo digito.
2.- la segunda modificacion es evaluar la raiz cuadra representado por el caracter '$' con un prioridad maxima. ejemplo Entrada : $(10*10) -30 ->salida 1 : 10 10 * $ 30 - salida2 : -20 que es el resultado de la evalucacion.
de antemano les agradeceria su ayuda.
el codigo es el siguiente:
clase evaluacion postfija
este es el codigo de la clase pila
y por ultimo la clase principal la cual testea el programa.
1.-ejemplo : Entrada : (100+5.75) + 100 -> salida : 100 5.75 + 100 +.
el problema es que solo acepta caracteres de 1 solo digito.
2.- la segunda modificacion es evaluar la raiz cuadra representado por el caracter '$' con un prioridad maxima. ejemplo Entrada : $(10*10) -30 ->salida 1 : 10 10 * $ 30 - salida2 : -20 que es el resultado de la evalucacion.
de antemano les agradeceria su ayuda.
el codigo es el siguiente:
Código (java) [Seleccionar]
class InToPost // infix to postfix conversion
{
private StackX theStack;
private String input;
private String output = "";
//--------------------------------------------------------------
public InToPost(String in) // constructor
{
input = in;
int stackSize = input.length();
theStack = new StackX(stackSize);
}
//--------------------------------------------------------------
public String doTrans() // lo traduce a postfijo
{
for(int j=0; j<input.length(); j++)
{
char ch = input.charAt(j);
theStack.displayStack("For "+ch+" "); // *diagnostico*
switch(ch)
{
case '+': // es + o -
case '-':
gotOper(ch, 1); // apila operadores
break; // (precedence 1)
case '*': // it's * or /
case '/':
gotOper(ch, 2); // apila operadores
break; // (precedence 2)
case '$':
gotOper(ch, 3); // apila operador raiz cuadrada
break; // (precedence 3)
case '(': // parentesis izquierdo
theStack.push(ch); // apilarlo
break;
case ')': // parentesis derecho
gotParen(ch); // apila
break;
default: // debe ser un operando
output = output + ch; // escribiendo ala salida
break;
} // fin del switch
} // fin del for
while( !theStack.isEmpty() ) // apila los restantes operadoeres
{
theStack.displayStack("While "); // *diagnostico*
output = output + theStack.pop(); // escribe la salida
}
theStack.displayStack("End "); // *diagnostico*
return output; // retorna el postfijo
} // fin de doTrans()
//--------------------------------------------------------------
public void gotOper(char opThis, int prec1)
{ // Obtuvo el operador de la entrada
while( !theStack.isEmpty() )
{
char opTop = theStack.pop();
if( opTop == '(' ) // if es un '('
{
theStack.push(opTop); // restaura '('
break;
}
else // es un operador
{
int prec2; // precedencia de nuevo operador
if(opTop=='+' || opTop=='-') //encuentra nuevo operador de precedencia
prec2 = 1;
else
prec2 = 2;
if(prec2 < prec1) // if precedencia de nuevo operador es menor
{ // que precedencia del viejo operador
theStack.push(opTop); // guarda el nuevo operador
break;
}
else // precedencia de nuevo operador no es menor
output = output + opTop; // que prec del viejo operador
} // fin del else (es un operador)
} // fin while
theStack.push(opThis); // apila nuevo operador
} // fin gotOp()
//--------------------------------------------------------------
public void gotParen(char ch)
{ // obtuvo parentesis derecho de la entrada
while( !theStack.isEmpty() )
{
char chx = theStack.pop();
if( chx == '(' ) // si es extraido '('
break; // esta listo
else // si es extraido el operador
output = output + chx; // output it
} // fin while
} // fin popOps()
//--------------------------------------------------------------
} // fin de la clase InToPost
clase evaluacion postfija
Código (java) [Seleccionar]
class ParsePost
{
private StackX theStack;
private String input;
//--------------------------------------------------------------
public ParsePost(String s)
{ input = s; }
//--------------------------------------------------------------
public int doParse()
{
theStack = new StackX(20); // crea una nueva pila
char ch;
int j;
int num1, num2, interAns;
for(j=0; j<input.length(); j++) // for para cada caracter (char),
{
ch = input.charAt(j); // lee la entrada
theStack.displayStack(""+ch+" "); // *diagnostico*
if(ch >= '0' && ch <= '9') // if es un numero
theStack.push((char) (ch-'0')); // lo apila
else // es operador
{
num2 = theStack.pop(); // extrae operandos
num1 = theStack.pop();
switch(ch) // hace la evaluacion aritmetica
{
case '+':
interAns = num1 + num2;
break;
case '-':
interAns = num1 - num2;
break;
case '*':
interAns = num1 * num2;
break;
case '/':
interAns = num1 / num2;
break;
case '$':
default:
interAns = 0;
} // end switch
theStack.push((char) interAns); // apila el resultado
} // fin del else
} // fin del for
interAns = theStack.pop(); // devuelve respuesta
return interAns;
} // fin doParse()
} // fin de la clase ParsePost
este es el codigo de la clase pila
Código (java) [Seleccionar]
class StackX
{
private int maxSize;
private char[] stackArray;
private int top;
//--------------------------------------------------------------
public StackX(int s) // constructor
{
maxSize = s;
stackArray = new char[maxSize];
top = -1;
}
//--------------------------------------------------------------
public void push(char j) // pone un elemento en el tope de la pila
{ stackArray[++top] = j; }
//--------------------------------------------------------------
public char pop() // toma un elemento del tope de la pila
{ return stackArray[top--]; }
//--------------------------------------------------------------
public char peek() // obtiene el tope de la pila
{ return stackArray[top]; }
//--------------------------------------------------------------
public boolean isEmpty() // verdadero si la pila westa vacia
{ return (top == -1); }
//-------------------------------------------------------------
public int size() // regresa el tamano
{ return top+1; }
//--------------------------------------------------------------
public char peekN(int n) // regresa el elemento al indice n
{ return stackArray[n]; }
//--------------------------------------------------------------
public void displayStack(String s)
{
System.out.print(s);
System.out.print("Stack (bottom-->tope): ");
for(int j=0; j<size(); j++)
{
System.out.print( peekN(j) );
System.out.print(' ');
}
System.out.println("");
}
//--------------------------------------------------------------
} // fin de la clase StackX
y por ultimo la clase principal la cual testea el programa.
Código (java) [Seleccionar]
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
class InfixApp {
public static void main(String[] args) throws IOException {
String input, output;
int eval;
while(true) {
System.out.print("introduce el infijo: ");
System.out.flush();
input = getString(); // lee un string de kbd
if( input.equals("") ) // sale del programa si es [Enter]
break;
// crea la traduccion
InToPost theTrans = new InToPost(input);
output = theTrans.doTrans(); // hace la traduccion
System.out.println("Postfix is " + output + '\n');
ParsePost aParser = new ParsePost(output);
eval = aParser.doParse(); // hace la evaluacion
System.out.println("Evaluates to " + eval);
} // fin del while
} // fin del main()
//--------------------------------------------------------------
public static String getString() throws IOException
{
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
String s = br.readLine();
return s;
}
//--------------------------------------------------------------
} // fin de la clase InfixApp