中文字幕精品亚洲无线码一区,国产亚洲视频在线播放,亚洲av成人一区二区三区在线播放

表達式求值Java粗糙版

/**
*
*/
package com.yovn.algo;

import java.util.Stack;
import java.util.Vector;

/**
* @author yovn
*
*/
public class Caculator {


    class Item
    {
        boolean ops;
        int value;

        Character opVal;
        int opPriority;
    }

    Stack<Item> opStack=new Stack<Item>();
    Vector<Item> calcStack=new Vector<Item>();
    /**
     *
     */
    public Caculator() {
        // TODO Auto-generated constructor stub
    }




    public int calc()
    {
        Stack<Item> tmp=new Stack<Item>();
        while(!calcStack.isEmpty())
        {
            Item it=calcStack.remove(0);

            if(!it.ops)
            {
                tmp.push(it);
            }
            else
            {
                int op2=tmp.pop().value;
                int op1=tmp.pop().value;
                Item newItem=new Item();
                newItem.ops=true;
                switch(it.opVal)
                {
                case '+':
                    newItem.value=op1+op2;

                    break;
                case '-':
                    newItem.value=op1-op2;
                    break;
                case '*':

                    newItem.value=op1*op2;
                    break;
                case '/':
                    newItem.value=op1/op2;
                    break;
                }
                tmp.push(newItem);
            }
        }
        return tmp.pop().value;
    }
    /**
     * 1)數字直接輸出
     * 2)開括號則壓棧
     * 3）閉括號把棧中元素依次輸出直到遇到開括號
     * 4）運算符時
     *     a)循環，當棧非空，并且棧頂元素不是開括號，并且棧頂運算符優先級不低于輸入的運算符的優先級，反復將其輸出
     *     b）把輸入運算符壓棧
     * 5）輸出棧內剩余元素
     * @param in
     * @return
     */
    public String transInfixToPosfix(String in)
    {
        char[] cin=in.toCharArray();
        StringBuffer buffer=new StringBuffer();

        for(int i=0;i<cin.length;i++)
        {
            Item newItem=new Item();
            newItem.opPriority=1;
            newItem.ops=false;

            switch(cin[i])
            {

            case '+':
                newItem.opPriority=1;
                newItem.ops=true;
                newItem.opVal='+';
                doOps(buffer, newItem);

                break;
            case '-':
                newItem.opPriority=1;
                newItem.ops=true;
                newItem.opVal='-';
                doOps(buffer, newItem);
                break;
            case '*':
                newItem.opPriority=2;
                newItem.ops=true;
                newItem.opVal='*';
                doOps(buffer, newItem);
                break;
            case '/':
                newItem.opPriority=2;
                newItem.ops=true;
                newItem.opVal='/';
                doOps(buffer, newItem);
                break;

            case '(':
                newItem.ops=true;
                newItem.opVal='(';
                opStack.push(newItem);

                break;
            case ')':
                boolean meetClose=false;
                while(!opStack.isEmpty())
                {
                    Item item=opStack.peek();
                    if(item.ops&&item.opVal!='(')
                    {
                        calcStack.add(item);
                        opStack.pop();
                        buffer.append(item.opVal);
                    }
                    else if(item.ops)
                    {
                        opStack.pop();
                        meetClose=true;
                        break;
                    }
                }
                if(!meetClose)
                {
                    throw new RuntimeException();
                }
                break;

            default:
                int j=i;
                for(;j<cin.length&&cin[j]>='0'&&cin[j]<='9';j++);
                if(j==i)
                {
                    throw new RuntimeException("wrong input

.");
                }
                newItem.ops=false;
                newItem.value=Integer.parseInt(new String(cin,i,j-i));
                buffer.append(newItem.value);
                calcStack.add(newItem);
                i=j-1;
                break;


            }
        }
        while(!opStack.isEmpty())
        {
            Item item=opStack.pop();
            calcStack.add(item);
            buffer.append(item.opVal);

        }
        return buffer.toString();

    }

    private void doOps(StringBuffer buffer, Item newItem) {
        while(!opStack.isEmpty())
        {
            Item item=opStack.peek();
            if(item.opVal!='('&&item.opPriority>=newItem.opPriority)
            {
                calcStack.add(item);
                opStack.pop();
                buffer.append(item.opVal);
            }
            else
            {
                break;
            }
        }
        opStack.push(newItem);
    }


    /**
     * @param args
     */
    public static void main(String[] args) {
        Caculator calc=new Caculator();

        System.out.println("1+2*3+7-(4/2+8)/5="+calc.transInfixToPosfix("1+2*3+7-(4/2+8)/5"));
        System.out.println("value is:"+calc.calc());

    }

}

posted on 2007-10-09 22:48 DoubleH 閱讀(996) 評論(1) 編輯收藏所屬分類: Memorandum

Feedback

# re: 表達式求值Java粗糙版 2007-12-20 21:45 sitinspring

以后要多來看看. 回復更多評論

新用戶注冊刷新評論列表


只有注冊用戶登錄后才能發表評論。




網站導航: 博客園 IT新聞 Chat2DB C++博客博問管理
相關文章: 求連續正整數使得其和為給定的一個正整數的構造性解法向上取整的一個應用《算法概論》第一章習題35證明（Wilson定理) 有意思的“電燈泡問題” 伸展樹與半伸展樹Java實現一種新的AVL平衡樹刪除操作的實現使用贏者樹的外部排序圖及其算法復習（Java實現) 三：最小支撐樹（Prim,Kruskal算法）圖及其算法復習（Java實現) 二：拓撲排序，最短路徑問題圖及其算法復習（Java實現) 一：存儲結構，深度優先周游，廣度優先周游

Java雜家

公告

常用鏈接

留言簿(15)

隨筆分類

隨筆檔案

相冊

搜索

積分與排名

最新評論

閱讀排行榜

評論排行榜

Feedback