Entry类:
package com.hy; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; // 此类用于把算术表达式送入解析器 public class Entry { public static void main(String[] args) throws IOException{ // 取得用户输入的表达式 BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); String rawExpression = null; System.out.print("请输入算术表达式:"); rawExpression = br.readLine(); // 得到合法的算术表达式 String expression=""; for(int i=0;i<rawExpression.length();i++){ // 拿到表达式的每个字符 char c=rawExpression.charAt(i); //System.out.print(c+","); if(Character.isDigit(c) || c=='+' || c=='-' || c=='*' || c=='/' || c=='(' || c==')' || c=='.'){ //System.out.print(c); expression+=c; }else{ System.out.print(" "+c+"不是合法的算术表达式字符."); System.exit(0); } } // 送去解析 Lexer p=new Lexer(expression); //p.print(); // Tree t=new Tree(p.getInfixList()); try { System.out.println("算式表达式"+expression+"的计算结果为:"+t.evaluate()); System.out.println("其后序表达式为:"+t.getPostfix()); System.out.println("从二叉树重新组建的中序表达式为"+t.getInfix()); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } } }
输出如下,当然还有可以调整的地方:
请输入算术表达式:(1.1+2.3)*(3+4) 算式表达式(1.1+2.3)*(3+4)的计算结果为:23.800001 其后序表达式为:1.1 2.3 + 3.0 4.0 + * 从二叉树重新组建的中序表达式为(1.1 + 2.3 )* (3.0 + 4.0 ) 请输入算术表达式:(1+2)*3-4*(6-5) 算式表达式(1+2)*3-4*(6-5)的计算结果为:5.0 其后序表达式为:1.0 2.0 + 3.0 * 4.0 6.0 5.0 - * - 从二叉树重新组建的中序表达式为(1.0 + 2.0 )* 3.0 - 4.0 * (6.0 - 5.0 ) 请输入算术表达式:1+2*(5-4)+6-7 算式表达式1+2*(5-4)+6-7的计算结果为:2.0 其后序表达式为:1.0 2.0 5.0 4.0 - * + 6.0 + 7.0 - 从二叉树重新组建的中序表达式为((1.0 + 2.0 * (5.0 - 4.0 ))+ 6.0 )- 7.0 请输入算术表达式:1+2*(6-4) 算式表达式1+2*(6-4)的计算结果为:5.0 其后序表达式为:1.0 2.0 6.0 4.0 - * + 从二叉树重新组建的中序表达式为1.0 + 2.0 * (6.0 - 4.0 ) 请输入算术表达式:2*(3+4) 算式表达式2*(3+4)的计算结果为:14.0 其后序表达式为:2.0 3.0 4.0 + * 从二叉树重新组建的中序表达式为2.0 * (3.0 + 4.0 ) 请输入算术表达式:1*2+3*4 算式表达式1*2+3*4的计算结果为:14.0 其后序表达式为:1.0 2.0 * 3.0 4.0 * + 从二叉树重新组建的中序表达式为1.0 * 2.0 + 3.0 * 4.0 请输入算术表达式:1+2+3+4 算式表达式1+2+3+4的计算结果为:10.0 其后序表达式为:1.0 2.0 + 3.0 + 4.0 + 从二叉树重新组建的中序表达式为((1.0 + 2.0 )+ 3.0 )+ 4.0
Lexer类:
package com.hy; import java.util.ArrayList; import java.util.List; import java.util.regex.Matcher; import java.util.regex.Pattern; // 此类用于将算术表达式解析成包含操作数和操作符的链表,扮演分词器的角色 public class Lexer { private List<String> list;// 用于存储中序表达式的链表 public List<String> getInfixList() { return list; } public Lexer(String expression){ list=new ArrayList<String>(); // 使用正则表达式分词 String regExp = "(\d+(\.*)\d*)|(\+)|(\-)|(\*)|(\/)|(\()|(\))"; Pattern pattern=Pattern.compile(regExp); Matcher matcher=pattern.matcher(expression); while(matcher.find()){ list.add(matcher.group(0)); } } public void print(){ for(String str:list){ System.out.println(str); } } }
Tree类:
package com.hy; import java.util.List; // 以算术表达式为基础构建一棵二叉树,它是算术表达式的语法树 public class Tree { // 根节点 private Node root; // infixList为分词完毕的中序表达式列表 public Tree(List<String> infixList){ root=build(infixList,0,infixList.size()); } // 构建一棵树,从根节点构建起 private Node build(List<String> list,int start,int end){ int depth=0;//记录深度,进一层括号加一,退出来减一 int plusDivideRightmostPos=-1;// 记录最右边的加减号位置 int multiDivideRightmostPos=-1;// 记录最右边的乘除号位置 // 操作数 if(start==end-1){ // 下标相差一,说明找到的是没有子节点的叶子节点,也即操作数节点 Node leafNode=new Node(NodeType.Digit,list.get(start)); return leafNode; } // 这个循环是为了找括号外最右边的运算符位置 for(int i=start;i<end;i++){ String operatorText=list.get(i);// 获得操作符的文字,如果是操作数直接ignore if(operatorText.equals("(")){ depth++; }else if(operatorText.equals(")")){ depth--; }else if(operatorText.equals("+") || operatorText.equals("-") ){ if(depth==0){ plusDivideRightmostPos=i; } }else if(operatorText.equals("*") || operatorText.equals("/") ){ if(depth==0){ multiDivideRightmostPos=i; } } } int rightMost=-1; if(plusDivideRightmostPos==-1 && multiDivideRightmostPos==-1){ // 整个算式被多余的括号括起来了,去掉这层多余的括号再做 return build(list,start+1,end-1); } // 优先取加减号的位置,因为它的计算优先级最低,应当最后算 rightMost=plusDivideRightmostPos; if(plusDivideRightmostPos==-1 && multiDivideRightmostPos>0){ // 括号外只有乘除号,如(1+2)*(3+4),这时只有取乘除号位置, rightMost=multiDivideRightmostPos; } // 如果能走到这里,则最右边括号外的运算符位置已经找到了,可以开始构建节点 String operator=list.get(rightMost); Node nodeOper=new Node(operator);// 这里创建的节点都是操作符节点,不是最终的叶子节点 // 以最右边的操作符为界,分两侧构建左右子节点 nodeOper.setLeftNode(build(list,start,rightMost)); nodeOper.setRightNode(build(list,rightMost+1,end)); // 返回构建完的节点 return nodeOper; } // 取二叉树的值 public float evaluate() throws Exception{ return this.root.getValue(); } // 后序遍历 private String postOrder(Node node){ if(node!=null){ String s=""; s+=postOrder(node.getLeftNode()); s+=postOrder(node.getRightNode()); s+=node.toString(); return s; } return ""; } // 从构建好的二叉树获得后序表达式 public String getPostfix(){ return postOrder(root); } // 中序遍历 private String inOrder(Node node){ if(node!=null){ String s=""; if(node.getType().equals(NodeType.OP_Plus) || node.getType().equals(NodeType.OP_Minus)){ s+="("; } s+=inOrder(node.getLeftNode()); s+=node.toString(); s+=inOrder(node.getRightNode()); if(node.getType().equals(NodeType.OP_Plus) || node.getType().equals(NodeType.OP_Minus)){ s+=")"; } return s; } return ""; } // 从构建好的二叉树获得中序表达式 public String getInfix(){ String s=""; s=inOrder(root); if(s.startsWith("(") && s.endsWith(")") && (root.getType()==NodeType.OP_Minus || root.getType()==NodeType.OP_Plus) ){ return s.substring(1, s.length()-1); }else{ return s; } } }
Node类:
package com.hy; // 二叉树节点类 public class Node { private NodeType type; private float value; private Node leftNode;// 左节点 private Node rightNode;// 右节点 public Node(){ type=NodeType.Undifined; value=0.0f; leftNode=null; rightNode=null; } public Node(String nodeTypeText){ if(nodeTypeText.equals("+")){ this.type=NodeType.OP_Plus; }else if(nodeTypeText.equals("-")){ this.type=NodeType.OP_Minus; }else if(nodeTypeText.equals("*")){ this.type=NodeType.OP_Multi; }else if(nodeTypeText.equals("/")){ this.type=NodeType.OP_Divide; }else{ this.type=NodeType.Undifined; } value=0.0f; leftNode=null; rightNode=null; } public Node(NodeType type){ this.type=type; value=0.0f; leftNode=null; rightNode=null; } public Node(NodeType type,String str){ this.type=type; this.value=Float.valueOf(str); leftNode=null; rightNode=null; } public Node(NodeType type,float value,Node leftNode,Node rightNode){ this.type=type; this.value=value; this.leftNode=leftNode; this.rightNode=rightNode; } public Node(NodeType type,Node leftNode,Node rightNode){ this.type=type; this.value=0; this.leftNode=leftNode; this.rightNode=rightNode; } public float getValue() throws Exception{ if(this.type==NodeType.Digit){ return value; }else if(this.type==NodeType.OP_Divide){ return leftNode.getValue()/rightNode.getValue(); }else if(this.type==NodeType.OP_Minus){ return leftNode.getValue()-rightNode.getValue(); }else if(this.type==NodeType.OP_Multi){ return leftNode.getValue()*rightNode.getValue(); }else if(this.type==NodeType.OP_Plus){ return leftNode.getValue()+rightNode.getValue(); }else{ throw new Exception("Not initialize"); } } public void setLeftNode(Node leftNode) { this.leftNode = leftNode; } public void setRightNode(Node rightNode) { this.rightNode = rightNode; } public Node getLeftNode() { return leftNode; } public Node getRightNode() { return rightNode; } public String toString(){ if(this.type==NodeType.Digit){ return String.valueOf(value)+" "; }else if(this.type==NodeType.OP_Divide){ return "/ "; }else if(this.type==NodeType.OP_Minus){ return "- "; }else if(this.type==NodeType.OP_Multi){ return "* "; }else if(this.type==NodeType.OP_Plus){ return "+ "; }else{ return "? "; } } public NodeType getType() { return type; } public void setType(NodeType type) { this.type = type; } public void setValue(float value) { this.value = value; } }
NodeType枚举:
package com.hy; // 节点类型 public enum NodeType { Undifined, OP_Plus, OP_Minus, OP_Multi, OP_Divide, Digit, }
--END-- 2019年9月4日15点42分