数据结构－栈－中缀表达式转后缀表达式

package com.jikefriend.stack;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * 中缀表达式转换成后缀表达式
 */
public class Infix
{

    /**
     * 用于存放操作符的栈
     */
    final static class StackX
    {
        private int maxSize;
        private char[] stackArray;
        private int top;

        public StackX(int s)
        {
            maxSize = s;
            stackArray = new char[maxSize];
            top = -1;
        }

        public void push(char c)
        {
            stackArray[++top] = c;
        }

        public char pop()
        {
            return stackArray[top--];
        }

        public char peek()
        {
            return stackArray[top];
        }

        public boolean isEmpty()
        {
            return top == -1;
        }

        public int size()
        {
            return top + 1;
        }

        public char peekN(int n)
        {
            return stackArray[n];
        }

        public void displayStack(String s)
        {
            System.out.print(s);
            System.out.print("Stack (bottom --> top): ");
            for (int i = 0; i < size(); i++)
            {
                System.out.print(peekN(i) + " ");
            }
            System.out.println();
        }
    }

    /**
     * 中缀表达式转换为后缀表达式的操作类
     */
    final static class InToPost
    {
        private StackX theStack;
        private String input;
        private String output = "";

        public InToPost(String in)
        {
            input = in;
            int stackSize = input.length();
            theStack = new StackX(stackSize);
        }

        public String doTrans()
        {
            for (int i = 0; i < input.length(); i++)
            {
                char ch = input.charAt(i);
                theStack.displayStack("For " + ch + " ");
                switch (ch)
                {
                    case '+':
                    case '-':
                        gotOper(ch, 1);                 //去与栈顶的操作符比较，'+'、'-'的优先级定义为1
                        break;
                    case '*':
                    case '/':
                        gotOper(ch, 2);                 //去与栈顶的操作符比较，'*'、'/'的优先级定义为2
                        break;
                    case '(':                           //左括号'('，直接压入栈中
                        theStack.push(ch);
                        break;
                    case ')':                           //右括号')'的情况，去栈中找左括号'('
                        gotParen(ch);
                        break;
                    default:                            //必须为一个操作数
                        output += ch;                   //写入输出
                        break;
                }
            }
            while (!theStack.isEmpty())                 //持续从栈中弹出操作符
            {
                theStack.displayStack("While ");        //诊断
                output = output + theStack.pop();
            }
            theStack.displayStack("End   ");            //诊断
            return output;                              //返回后缀表达式
        }

        public void gotOper(char opThis, int prec)
        {
            while (!theStack.isEmpty())
            {
                char opTop = theStack.pop();
                if (opTop == '(')                       //如果栈顶获取的符号是‘(’
                {
                    theStack.push(opTop);               //则再次将其存入栈中
                    break;
                }
                else                                    //如果是操作符
                {
                    int _prec;                          //栈顶获取的符号优先级
                    if (opTop == '+' || opTop == '-')
                        _prec = 1;
                    else
                        _prec = 2;
                    if (_prec < prec)                   //比较栈顶获取的符号和新符号的优先级
                    {
                        theStack.push(opTop);           //如果栈顶获取的符号优先级低，则再次将其压入栈中
                        break;
                    }
                    else                                //如果新符号优先级低，则将栈顶获取的符号直接写入输出
                    {
                        output += opTop;
                    }
                }
            }
            theStack.push(opThis);                      //最后将新符号压入栈中
        }

        public void gotParen(char ch)
        {
            while (!theStack.isEmpty())
            {
                char chx = theStack.pop();
                if (chx == '(')                         //如果从栈中弹出的是‘(’，结束
                    break;
                else                                    //如果从栈中弹出的是操作符号，写入输出
                    output += chx;
            }
        }
    }

    public static void main(String[] args) throws IOException{
        String input, output;
        while (true)
        {
            System.out.print("Enter infix: ");
            System.out.flush();
            input = getString();
            if (input.equals(""))
                break;
            InToPost theTrans = new InToPost(input);
            output = theTrans.doTrans();
            System.out.println("Postfix is " + output);
        }
    }

    public static String getString() throws IOException
    {
        InputStreamReader isr = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(isr);
        String s = br.readLine();
        return s;
    }

}

摘自《java数据结构与算法(第二版)》 [美] Robert Lafore 著