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:

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

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

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.

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