逆波兰式计算

下面的逆波兰式，不支持单目运算，以及｛｝、〔〕这两类的括号运算。对精度提供了设置，根据你输入的浮点数的小数位的位数来适应，返回和操作数相同位数的结果。由于写的匆忙，好存在很多缺陷。不足的地方希望能给出批评。

java 代码

1.stack.java

import java.util.LinkedList;

/**
 * @author
 *
 * @2007-2-8
 * @to-Email
 */
public class Stack {

    private LinkedList stack = new LinkedList();
    private int top = -1;

    public void push(Object obj)
    {
        top++;
        stack.addFirst(obj);
    }

    public Object pop()
    {
        Object obj = stack.getFirst();
        top--;
        stack.removeFirst();
        return obj;
    }

    public Object top()
    {
        return stack.getFirst();
    }

    public boolean isEmpty()
    {
        if(top == -1 || stack.size() == 0)
            return true;
        else
            return false;
    }
}

2.将输入的表达式转换成逆波兰式

java 代码

package structure;

import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;

/**
 * @author wei
 *
 * @2007-2-8
 * @to-Email
 */
public class Calculate {

    private List expression = new ArrayList();
    private List operator = new ArrayList();
    private Stack stack;

    public Calculate(String input)
    {
        stack = new Stack();
        StringTokenizer st = new StringTokenizer(input, "+-*/()", true);
        while (st.hasMoreElements()) {
            expression.add(st.nextToken());
        }
    }

    public static boolean isOperator(String operator) {
        if ("+".equals(operator) || "-".equals(operator)
                || "*".equals(operator) || "/".equals(operator)
                || "(".equals(operator) || ")".equals(operator))
            return true;
        else
            return false;
    }

    public List doTrans()
    {
        for(int i = 0;i
        {
            String str = (String)expression.get(i);

            if(str.equals("+") || str.equals("-"))
            {
                gotOper(str,1);
            }else if(str.equals("*") || str.equals("/"))
            {
                gotOper(str,2);
            }else if(str.equals("("))
            {
                stack.push("(");
            }else if(str.equals(")"))
            {
                gotParen(str);
            }else
            {
                operator.add(str);
            }
        }

        while(!stack.isEmpty())
        {
            operator.add(stack.pop());
        }
        return operator;
    }

    public void gotOper(String opThis, int prec1) { // got operator from input
        while (!stack.isEmpty()) {
            String opTop = (String) stack.pop();
            if (opTop.equals("(")) // if it's a '('
            {
                stack.push(opTop); // restore '('
                break;
            } else // it's an operator
            {
                int prec2; // precedence of new op

                if (opTop.equals("+")  || opTop.equals("-")) // find new op prec
                    prec2 = 1;
                else
                    prec2 = 2;
                if (prec2 < prec1) // if prec of new op less
                { // than prec of old
                    stack.push(opTop); // save newly-popped op
                    break;
                } else
                    // prec of new not less
                    //output = output + opTop;
                    operator.add(opTop);// than prec of old
            } // end else (it's an operator)
        } // end while
        stack.push(opThis); // push new operator
    }

    public void gotParen(String ch) { // got right paren from input
        while (!stack.isEmpty()) {
            String chx = (String)stack.pop();
            if (chx.equals("(")) // if popped '('
                break; // we're done
            else
//              output = output + chx; // output it
            operator.add(chx);
        }
    }


    public static void main(String[] args)
    {
        Calculate calculate = new Calculate("2+(4-3)*2");
        List result = calculate.doTrans();

        for(int i=0;i
        {
            System.out.println(result.get(i));
        }
    }
}

3.后序表达式计算

java 代码

package structure;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;

/**
 * @author
 *
 * @2007-2-8
 * @to-Email
 */
public class PostControl {

    private List operator = new ArrayList();
    private Stack stack = new Stack();

    public PostControl(List list)
    {
        operator = list;
    }

    public String doParse()
    {
        BigDecimal z = new BigDecimal("0.00");
        for(int i= 0;i
        {
            String str = (String)operator.get(i);

            if(!isOperator(str))
            {   stack.push(str);}
            else
            {
                BigDecimal y = new BigDecimal((String)stack.pop());
                BigDecimal x =new BigDecimal((String)stack.pop());

                if(str.equals("+"))
                {
                    z = x.add(y);
                }else if(str.equals("-"))
                {
                    z= x.subtract(y);
                }else if(str.equals("*"))
                {
                    z = x.multiply(y);
                }else if(str.equals("/"))
                {
                    z = x.divide(y);
                }else
                {
                    z= new BigDecimal("0.00");
                }

                stack.push(String.valueOf(z));
            }
        }
        return (String)stack.pop();
    }


    public static boolean isOperator(String operator) {
        if ("+".equals(operator) || "-".equals(operator)
                || "*".equals(operator) || "/".equals(operator)
                || "(".equals(operator) || ")".equals(operator))
            return true;
        else
            return false;
    }


    public static void main(String[] args)
    {
        Calculate calculate = new Calculate("2+((4.5-3)*2+3)*2");
        List result = calculate.doTrans();

        PostControl p = new PostControl(result);
        System.out.println(p.doParse());
    }
}