Infix to postfix expression

Question

Hi all!
I'm currently trying to finish up an assignment that is due in a few hours. Here's my delimma, according to the text book and the professor the following algorithm to convert an infix to postfix is as follows:
1. Two stacks will be used in the conversion(expressionStack and operatorStack)
2. if an operand is encountered, push onto expressionStack
3. if an operator is encountered, including the "(" push onto the temporary stack
4. if a ")" is encountered, pop each operator off the temporaryStack and push it into the expressionStack until a "(" is encountered in the temporaryStack. Once a "(" is encountered, pop that off the temporaryStack.
Traverse through the infix expression until the end is reached then pop everything from the temporaryStack onto the expression stack.
Here's the code I wrote for it:
public String convertInfixToPostfix() throws PostfixConversionException {
  //if there is an unbalace set of parenthesis, throw exception
    if(!isBalance()) {
      throw new PostfixConversionException("Unable to convert infix expression");
    for(int i = 0; i < this.infixExpression.length(); i++) {
      char ch = this.infixExpression.charAt(i);
      //if ch is an operand, push onto stack
      switch(ch) {
        case '0':
        case '1':
        case '2':
        case '3':
        case '4':
        case '5':
        case '6':
        case '7':
        case '8':
        case '9':
        this.expressionStack.push("" + ch);
        break;
        //if ch is an operator or a '(', push onto temporaryOperator stack
        case '+':
        case '-':
        case '*':
        case '/':
        case '%':
        case '(':
          this.temporaryOperator.push("" + ch);
          break;
        /*if ch is ')' push all operators from temporaryOperator stack onto expressionStack until
         * until a matching '(' is encountered*/
        case ')':
          //while the top does not equal "(" pop everything off temporaryOperator stack and onto expression stack until a '(' is encountered
          while(!"(".equals(this.temporaryOperator.top())) {
            this.expressionStack.push(this.temporaryOperator.pop());
          //removes one open matching '('
          this.temporaryOperator.pop();
          break;
        default:
          System.out.println("Unable to converted due to invalid characters entered");
          break;
    //while expressionStack is not empty, push everything into temporaryOperator stack
    while(!this.expressionStack.isEmpty()) {
      this.temporaryOperator.push(this.expressionStack.pop());
    while(!this.temporaryOperator.isEmpty()) {
      this.postfixExpression = this.postfixExpression + this.temporaryOperator.pop();
    return this.postfixExpression;
  }The problem is, unless I did the code wrong (which I don't think i did), the method incorrectly converts the infix to the postfix expression. Meaning the algorithm provided by the text book and professor is incorrect. Are there other ways of converting an infix to postfix expression?

Answer 1

Well using 2 stacks is same as 1 stack and 1
StringBuffer. So I'd get rid of your temporary stack.
Tokens either get pushed onto the operator stack or
postfix stack.I wish I could get rid of the temporary stack and use a StringBuffer, but the professor wants two stacks used.
Brackets are only slightly more difficult. If you
have opening bracket, simply push it onto the
operator stack. If you have a closing bracket pop
tokens off the operator stack onto the postfix stack
until you encounter an opening bracket then you
simply pop it off the stack and discard it.So basically what you're saying is exactly what my code is doing, only with two stacks. However it only works if the infix entered has to do only one operations like 4-8 or 8+3, etc..but when it converts a longer expression like 0-(((7-8+3*(9/1)*2)+5)*6), postfix is 078391/2**-56*- and result is 300. but when I entered the infix in a calculator, the result is -384. I check my compute method and Im pretty sure that is correct. So that leaves the conversion method. In any case heres the compute method, I might be wrong, but I'm pretty sure I got that down.
1. when a operand is encountered, push it into stack
2. when an operator is encountered, pop two operands off and compute, then push it back into the stack.
public double computeResult(String postfix) throws PostfixArithmeticException {
    //local variables
    Stack computePostfix = new Stack();
    int countOperators = 0;
    int countOperands = 0;
    //goes through the postfix and determines number of operators and operands
    for(int i = 0; i < postfix.length(); i++) {
     char ch = postfix.charAt(i);
     if(ch == '+' || ch == '-' || ch == '*' || ch == '/' || ch == '%') {
       countOperators++;
     else
       countOperands++;
    //test if there are enough operators and operands, number of operators should be 1 less than operands
    if((countOperators + 1) != countOperands || postfix.length() == 1) {
      //throw PostfixArithmeticException if there are not enough operators or operands
      throw new PostfixArithmeticException("Unable to compute postfix expression.");
    //otherwise, compute postfix expresstion
    for(int i = 0; i < postfix.length(); i++) {
      char ch = postfix.charAt(i);
      //if the character is not a operator, push onto a stack
      if(ch != '+' && ch != '-' && ch != '*' && ch != '/' && ch != '%') {
        computePostfix.push("" + ch);
      //otherwise, if an operator, pop two operands off the stack, compute with operator and push back on stack
      else {
        double operand2 = Double.parseDouble("" + computePostfix.pop());
        double operand1 = Double.parseDouble("" + computePostfix.pop());
        switch(ch){
          case '+':
            this.result =  operand1 + operand2;
            break;
          case '-':
            this.result =  operand1 - operand2;
            break;
          case '*':
            this.result =  operand1 * operand2;
            break;
          case '/':
            this.result =  operand1 / operand2;
            break;
          case '%':
            this.result =  operand1 % operand2;
            break;
        computePostfix.push("" + result);
    //return the result of the computation
    this.result = Double.parseDouble("" + computePostfix.pop());
    return result;
  }Also, I've tested that there should be the correct number of operators to an operand (which is the number of operators is always one less than number of operands)