带堆栈的Java Infix / Postfix转换器

Question

I'm supposed to implement 3 functions in the following code.

Functions:
    1. evaluate arithmetic expression in postfix
    2. convert arithmetic expression from infix to postfix
    3. convert arithmetic expression from postfix to infix

I don't know at all where I could start and how the functions need to look / made up at all. If you could help me with just one of these 3 functions, I would probably be able to do the other 2 myself.

Here is the code:

import java.util.Stack;

public class Postfix {

    public static int evalPostfix(String postfix) {
        // TODO
    }

    public static String infixToPostfix(String infix) {
        // TODO
    }

    public static String postfixToInfix(String postfix) {
        // TODO
    }

    public static void main(String[] args) {
        String infix1 = "(3-(7*2))";
        String postfix1 = "372*-";
        int eval1 = -11;

        String infix2 = "((7+1)*((3-6)*(5-2)))";
        String postfix2 = "71+36-52-**";
        int eval2 = -72;

        System.out.println("             postfix1: " + postfix1);
        int n = evalPostfix(postfix1);
        System.out.println("evalPostfix(postfix1): " + n);
        if (n == eval1) {
            System.out.println("                       Right!");
        } else {
            System.out.println("                       Wrong!");
        }
        System.out.println();

        System.out.println("                infix1: " + infix1);
        String s = infixToPostfix(infix1);
        System.out.println("infixToPostfix(infix1): " + s);
        if (s.equals(postfix1)) {
            System.out.println("                       Right!");
        } else {
            System.out.println("                       Wrong!");
        }
        System.out.println();

        System.out.println("                postfix1: " + postfix1);
        s = postfixToInfix(postfix1);
        System.out.println("postfixToInfix(postfix1): " + s);
        if (s.equals(infix1)) {
            System.out.println("                       Right!");
        } else {
            System.out.println("                       Wrong!");
        }
        System.out.println();

        System.out.println("             postfix2: " + postfix2);
        n = evalPostfix(postfix2);
        System.out.println("evalPostfix(postfix2): " + n);
        if (n == eval2) {
            System.out.println("                       Right!");
        } else {
            System.out.println("                       Wrong!");
        }
        System.out.println();

        System.out.println("                infix2: " + infix2);
        s = infixToPostfix(infix2);
        System.out.println("infixToPostfix(infix2): " + s);
        if (s.equals(postfix2)) {
            System.out.println("                       Right!");
        } else {
            System.out.println("                       Wrong!");
        }
        System.out.println();

        System.out.println("                postfix2: " + postfix2);
        s = postfixToInfix(postfix2);
        System.out.println("postfixToInfix(postfix2): " + s);
        if (s.equals(infix2)) {
            System.out.println("                       Right!");
        } else {
            System.out.println("                       Wrong!");
        }
        System.out.println();
    }
}

Answer 1

Here is some incomplete pseudocode to help you:

function int evalPostfix(string postfix)

  repeat

    // Fetch the next item.
    item <- get next item from postfix

    // Process the current item.
    if (item is operand)
      push item onto stack
    else if (item is operator)
      pop required number of operands from the stack
      push operator(operands) onto stack
    else
      throw error "Unrecognised item: " + item + " found."
    end if

  until (no more items in postfix)

  return pop from stack

end function

You will need separate operator functions for each operator that your code needs to deal with.

Answer 2

This is a classic 'Stack' data structure problem.

May be you have already given it a try with Stacks (you have a stack import.), you can also solve that with regular expressions or binary trees etc,

in case you just want an idea to solve that, hope this may help:

infix to postfix conversion with stacks:

Algorithm:

1. Scan the input infix expression from left to right.
2. If that's an operand add it to your temporary string.
3. else if the order of precedence of the operator is more than the operator in stacks or stack is empty then push it to stack.
4. If it is '(', add that to stack.
5. else if it is ')', pop and add item to output string until an '(' comes.
6. keep doing 2-5 util string have more characters.

static Stack<String> stack;

private static String doInfixToPostfix(String exp) {
    stack = new Stack<String>();
    String output = "";
    for(int i=0;i<exp.length();i++){

        if(exp.charAt(i) == '('){
            stack.push("(");
        }
        else if(exp.charAt(i) == ')'){
            while(stack.size()>0 && stack.peek() != "("){
                output+= stack.pop();
            }
            if(stack.size()>0 && stack.peek() != "(")
                return "INVALID";
            else
                stack.pop();
        }
        else if(isOperand("" + exp.charAt(i))){
            //Its a Number
            //It could be replaced to get more than one digits.....
            output+= exp.charAt(i);;
        }
        else{
            //Its a operator
            while(stack.size()>0 && (priority("" + exp.charAt(i)) < priority(stack.peek()))){
                output += stack.pop();
            }
            stack.push("" + exp.charAt(i));
        }
    }
    while(stack.size()>0){
        output+=stack.pop();
    }
    return output;
}


private static int priority(String value) {
    if(value == "+" || value == "-") return 1;
    else if(value == "*" || value == "/") return 2;
    else if(value == "^") return 3;

    return 0;
}

//This could be modified to accept more than one digits...
private static boolean isOperand(String value) {
    try{
        Integer.parseInt(value);
    }
    catch(NumberFormatException e){return false;}
    return true;
}

and hey, instead comparing outputs by those very long code blocks, you could have simply used assertEquals() test cases.