中缀表达式转后缀表达式---栈--二叉树---四则运算

  1 mport java.util.Arrays;
  2 import java.util.HashSet;
  3 import java.util.Random;
  4 import java.util.Set;
  5 
  6 /**
  7  * Created by hfz on 2016/7/30.
  8  */
  9 public class Stack_Array implements Stack {
 10     public static int CAPACITY=40;
 11     protected int capacity;
 12     protected int top=-1;
 13     protected Object[] S;
 14     public Stack_Array(int capacity){
 15         this.capacity=capacity;
 16         S=new Object[capacity];
 17     }
 18     public Stack_Array(){
 19         this(CAPACITY);//一般情况下，使用this.方法名调用自身方法，不过在构造方法里可以使用this()的形式调用其他构造函数
 20     }
 21     public void push(Object ele) throws ExceptionStackFull {
 22         if(getSize()==CAPACITY){
 23             throw new ExceptionStackFull("栈溢出！");
 24         }
 25         S[++top]=ele;
 26     }
 27     public Object pop() throws ExceptionStackEmpty{
 28         if(isEmpty()){
 29             throw new ExceptionStackEmpty("栈为空，不能出栈！");
 30         }
 31         Object ele=S[top];
 32         S[top--]=null;
 33         return ele;
 34     }
 35 
 36     public Object top() throws ExceptionStackEmpty{
 37         if(isEmpty()){
 38             throw new ExceptionStackEmpty("栈为空，没有栈顶元素！");
 39         }
 40         return S[top];
 41     }
 42     public boolean isEmpty(){
 43         return (top<0);
 44     }
 45     public int getSize(){
 46         return top+1;
 47     }
 48 
 49 public static void main(String [] args){
 50         String s="9 + ( 3 - 1 ) * 3 + 10 / 2";
 51         String s1="20 * ( ( 2.44 - 1.8 ) / 0.4 + 0.15 )";
 52 
 53         System.out.println(reversePlishNotation2(s));
 54         System.out.println(reversePlishNotation2(s1));
 55         inverseArray();
 56 
 57 
 58     }
 59 
 60 /*
 61     中缀表达式以#作为结束标志，以空格分割各个元素。
 62     中缀表达式转化为后缀表达式(逆波兰表达式)的方法
 63     1.从左向右扫描中缀表达式，遇到数字就直接输出。遇到运算符，如果其优先级高于栈顶元素或栈为空，入栈。如果低于栈顶
 64     元素优先级，则栈顶元素出栈输出，一直到栈顶元素的优先级低于或等于此运算符。如果两个运算符优先级相同的话，弹出栈顶元素，然后再将运算符入栈。
 65 
 66     2.对于小括号做另外处理，如果是左括号“(”，直接入栈。右括号"）"的话，栈顶元素出栈输出，一直到栈顶元素为“（”，将“（”出栈
 67     ，不过并不输出。右括号“）”并不入栈，直接丢弃。
 68     3.扫描完成之后，如果栈中还有元素，依次输出。
 69      */
 70     public static String reversePlishNotation2(String str){
 71         Stack_Array notationStack = new Stack_Array();
 72         String[] expressionString=str.split(" ");
 73         int expressionLength = expressionString.length;
 74         String currentString = "0";
 75         StringBuilder sb = new StringBuilder();
 76         Set<String> notationSet=new HashSet<>();
 77         notationSet.add("+");
 78         notationSet.add("-");
 79         notationSet.add("*");
 80         notationSet.add("/");
 81         notationSet.add("(");
 82         notationSet.add(")");
 83         String topElement="null";
 84         for (int i = 0; i <expressionLength ; i++) {
 85             currentString=expressionString[i];
 86             if(!notationSet.contains(currentString)){
 87              sb.append(currentString).append(" ");
 88             }
 89             else{//不是数字，而是操作符
 90                 try{
 91                     topElement=(String)notationStack.top();
 92                 }
 93                 catch (ExceptionStackEmpty ex){
 94                     notationStack.push(currentString);
 95                     continue;
 96                 }
 97                 if(currentString.equals(")")){//当前扫描的字符是")"，则操作符出栈至栈顶元素是"(",同时添加操作符，最后删除"("。
 98                     while(!topElement.equals("(")) {
 99                         sb.append(topElement).append(" ");
100                         try {
101                             notationStack.pop();
102                             topElement = (String) notationStack.top();
103                         }
104                         catch (ExceptionStackEmpty ex){
105                             break;
106                         }
107                     }
108                     if(topElement.equals("(")){
109                         notationStack.pop();
110                     }
111                 }
112                 else if(currentString.equals("(")||topElement.equals("(")){//如果扫描字符或者栈顶字符是"("，则扫描字符直接入栈。
113                 // 即使扫描字符是")"也不会入栈，因为上面一层的判断条件，要求出栈至"("。
114                     notationStack.push(currentString);
115                 }
116                 else if(currentString.equals("+")||currentString.equals("-")){
117                     //如果扫描字符是"+"或者"-",则一直出栈至栈顶元素为"+"或者"-"或者"("。如果最终栈顶元素是"("，则扫描操作符直接入栈，否则，弹出栈顶
118                     //元素，然后扫描的操作符再入栈。
119                     while (!topElement.equals("+")&&!topElement.equals("-")&&!topElement.equals("(")){
120                         sb.append(topElement).append(" ");
121                         try{
122                             notationStack.pop();
123                             topElement=(String)notationStack.top();
124                         }
125                         catch (ExceptionStackEmpty ex){
126                             break;
127                         }
128                     }
129                     if(topElement.equals("+")||topElement.equals("-")){
130                         sb.append((String)notationStack.pop()).append(" ");
131                     }
132                     notationStack.push(currentString);
133                 }
134                 else if(currentString.equals("*")||currentString.equals("/")){
135                     //如果扫描的操作符是"*"或者"/"，如果栈顶元素是同优先级的"*"或者"/",首先将栈顶元素出栈，然后扫描的操作符入栈。否则，直接入栈。
136                     if(topElement.equals("*")||topElement.equals("/")){
137                         sb.append((String) notationStack.pop()).append(" ");
138                     }
139                     notationStack.push(currentString);
140                 }
141             }
142         }
143         //扫描完成整个表达式之后，如果栈内还有元素，则依次全部出栈。
144         while (!notationStack.isEmpty()){
145             sb.append(notationStack.pop()).append(" ");
146         }
147         return sb.toString();
148     }
149 
150 
151 }
152 class ExceptionStackFull extends RuntimeException{
153     public ExceptionStackFull(String err){
154         super(err);
155     }
156 }