突然之間心血來潮,就是想試一試資料結構怎麼用.到現在才感覺的,資料結構是一種思想,一種思維方式,用怎樣的方式去解決怎樣的問題,這些是資料結構和演算法給我們的.

言歸正傳吧,說說這個小計算器(其實還有太多需要擴充套件和改進的地方).暫時只侷限在加減乘除,因為定義的是int型別的,所以也限制在整數運算吧.

主要思路是這樣的:計算器最主要的部分是獲取使用者輸入,然後根據演算法將獲取到的輸入儲存成為二叉樹.當然,肯定要用棧儲存的.

先看一下簡單的分析:

1+2-3:  儲存成二叉樹應該是這樣的:節點上的值為運算子,左右孩子為數值:

     +

    /   \

  +    3

/    \

1    2  

也就是說,存好後用後序方法來進行讀取,然後計算.

如果有*和/,則如下:

1+2*3-6/2:

                   -

               /     \

             +       /

            /  \    / \

           1   *  6  2

                / \

               2  3   

其實,從這些分析上,可以得出一個結論,暫且是對於這個計算器範圍內的結論(沒有括號之類的...)

(1)兩個棧,一個CTack,用來存放暫時的操作符,一個TTack,用來存放二叉樹.兩個棧結構,一個棧存放的是String型別,另一個存放二叉樹Node型別.

(2)一次對使用者輸入的字元進行遍歷,通過下面的原則判斷是否壓棧還是出棧組成二叉樹.

   方式:首先,在輸入字元是數字時,先建立一個TTack,左右孩子賦值為null,data值賦值為數字.

          輸入遍歷到操作符時:a: CTack為空;b:CTack當前操作符優先順序<讀入的操作符 ; 壓棧CTack

                                      aa:CTack當前操作符優先順序>=讀入操作符優先順序,新建Node,出棧TTack中的兩個Node分別

                                            作為新Node的左右孩子,操作符作為節點值,之後再次壓棧TTack.

(3)讀完後,如果CTack還不是null,則以此取出TTack中的兩個Node作為新Node的左右孩子,CTack出棧的操作符作為節點值.之後壓棧.

思路大體就是這樣,這個過程中其實有很多問題,其中比較難的是:如果操作符和已經有的是相等的關係,那麼就是迴圈進行新建節點,壓棧這些操作.

核心程式:

package com.pipi.MainProcess;

import com.pipi.structure.Node;
import com.pipi.structure.OperatorStacks;
import com.pipi.structure.Stacks;
import com.pipi.util.CheckPriority;
import com.pipi.util.Operate;


public class Structure {
	OperatorStacks CTack = new OperatorStacks(); //存放符號
	Stacks TTack = new Stacks(); //存放二叉樹結構
	
	private StringBuffer dowithstr = new StringBuffer();
	public String DowithStr(String getStr){
		char[] cc = getStr.toCharArray();
		String ch = new String();
		for (int i = 0;i < cc.length; i++){
			if(!Operate.isOperate(String.valueOf(cc[i]))){//如果是數字
				ch = ch + String.valueOf(cc[i]);
				int j = (i+1) == cc.length?(cc.length-1):i+1;
				if(Operate.isOperate(String.valueOf(cc[j])) || cc.length == i+1){
					Node n = new Node();
					n.setData(ch);
					n.setLchild(null);
					n.setRchild(null);
					TTack.push(n);
					ch = "";
				}
			}else{
				// 如果棧裡面當前操作符優先順序小於或者等於ch優先順序,則壓棧ch
				while(CheckPriority.getPriority(CTack.getFirstStr()) >= CheckPriority.getPriority(String.valueOf(cc[i]))){// 如果棧裡面當前操作符優先順序大於ch優先順序,則棧裡面當前操作符出棧,並取得TTack中兩個運算元進行運算
					Node a = TTack.pop();//第一個出棧
					Node b = TTack.pop();//第二個出棧
					Node n = new Node();
					n.setData(CTack.pop());
					n.setLchild(b);
					n.setRchild(a);
					TTack.push(n);
//					int m = CTack.getPoint()>0?(CTack.getPoint()-1):0;
//					CTack.setPoint(m);
					
				}
					CTack.push(String.valueOf(cc[i]));
			}
			}
		while(CTack.getPoint() > 0){
			Node a = TTack.pop();//第一個出棧
			Node b = TTack.pop();//第二個出棧
			
			Node n = new Node();
			
			n.setData(CTack.pop());
			n.setLchild(b);
			n.setRchild(a);
			TTack.push(n);
			
		}
		//計算最後的值
		int result = Operate.getResult(TTack.pop());
		
		/**
		 * 遍歷二叉樹元素,得出結果後沒有用啦
		 */
		int j = TTack.getPoint();  //當前棧中的個數
		for(int i = 0; i < j; i++){
			Node n = TTack.pop();
			System.out.println(n.getData()+"--------from the getData().");
			System.out.println(n.getLchild()+"--------from getLchild().");
			System.out.println(n.getRchild()+"--------from getRchild().");
		}
		
		/**
		 * 遍歷操作符,最後沒有了
		 */
		int k = CTack.getPoint();
		for(int i = 0; i < k; i++){
			System.out.println(CTack.pop());
		}
//		return "";
		return result+"";
	}
}

對棧的操作:

package com.pipi.structure;

public class OperatorStacks {
	private int point = 0; //當前位置
	private String[] sb = new String[100]; //當前位置的內容
	
	/**
	 * 獲取最上面的元素
	 * 如果有,則返回,如果沒有,則返回一個"###"
	 */
	public String getFirstStr(){
		
		if(point>0){
			return sb[point-1];
		}
		return "###";
	}
	
	public String pop(){
		if(point > 0){
			point = point - 1;
		}
		return sb[point];
		
	}
	
	public void push(String n){
		sb[point] = n;
		point++;
	}

	public int getPoint() {
		return point;
	}

	public void setPoint(int point) {
		this.point = point;
	}

	public String[] getSb() {
		return sb;
	}

	public void setSb(String[] sb) {
		this.sb = sb;
	}

	

	
}

工具操作:其中getResult方法用到了遞迴呼叫的方法.

package com.pipi.util;

import com.pipi.structure.Node;
import com.pipi.structure.OperatorStacks;
import com.pipi.structure.Stacks;

/**
 * 兩個數之間的計算
 * @author ya皮皮
 *
 */
public class Operate {
	public static String opr(String str, int num2, int num1){
		if(str.equals("+")){
			return (num2 + num1 +"");
		}else if(str.equals("-")){
			return (num2-num1 +"");
		}else if(str.equals("*")){
			return (num2*num1 +"");
		}else{
			if(num1!=0)
				{
				return (num2/num1 +"");
				}
			return 0+"";
				}
			
	}
	
	/**
	 * 
	 * @param TTack
	 * @param CTack
	 * @return
	 */
	
	//計算
	public static int getResult(Node n){
		String result = new String();
		if(null == n.getLchild() && null == n.getRchild()){
			result = n.getData();
		}else{
			result = opr(n.getData(),getResult(n.getLchild()),getResult(n.getRchild()));
		}
		return Integer.parseInt(result);
	}

	/**
	 * 判斷是不是操作符
	 */
	public static boolean isOperate(String str){
		return "+-*/".indexOf(str) != -1?true:false;
	}
	
}

 定義優先順序:

public class CheckPriority {
	public static int getPriority(String s){
		if(null == s){
			return 0;
		}
		if(s.equals("*") || s.equals("/")){ //* / 是1級
			return 2;
		}else if(s.equals("+") || s.equals("-")){ // + -是0級
			return 1;
		}else{
			return -1;
		}
	}
}

定義二叉樹:

package com.pipi.structure;
/**
 * 
 * @author pipi
 * 定義二叉樹
 */
public class Node {
	String data = new String(); //資料
	Node lchild = null; //左孩子,如果沒有,設定為null
	Node rchild = null; //右孩子,如果沒有,設定為null
	public String getData() {
		return data;
	}
	public void setData(String data) {
		this.data = data;
	}
	public Node getLchild() {
		return lchild;
	}
	public void setLchild(Node lchild) {
		this.lchild = lchild;
	}
	public Node getRchild() {
		return rchild;
	}
	public void setRchild(Node rchild) {
		this.rchild = rchild;
	}
	
	
}

總結:

其實,這個程式只是實現了一個思想,還有很多沒有考慮到的地方,還有很多程式碼需要重構.總的來說,學會了這種思想也是一個小小的進步,接下來會好好完善一下程式碼.

GOGO~