亚洲精品无码av片,亚洲av无码成人精品区在线播放,亚洲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)循環(huán)，當棧非空，并且棧頂元素不是開括號，并且棧頂運算符優(yōu)先級不低于輸入的運算符的優(yōu)先級，反復將其輸出
     *     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 閱讀(997) 評論(1) 編輯收藏所屬分類: Memorandum

Feedback

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

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

新用戶注冊刷新評論列表


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




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

Java雜家

公告

常用鏈接

留言簿(15)

隨筆分類

隨筆檔案

相冊

搜索

積分與排名

最新評論

閱讀排行榜

評論排行榜

Feedback