栈-----括号匹配+表达式计算

第1题： 算术表达式里面括号是否匹配，如 3+{2(5*3-1)-[1+(3-5)]}匹配，3+ 2(5*3-1)-[1+(3-5)]} 不匹配。

package com.sheepmu.text;import java.util.Stack;   /*  算术表达式里面括号是否匹配，如 3+{2(5*3-1)-[1+(3-5)]}匹配，3+ 2(5*3-1)-[1+(3-5)]} 不匹配。   *    * 思路:出现的右括号需与离他最近的左括号配对！！   * 遇到左括号入栈，越到右括号时：若栈不为空且和栈顶相同，则栈顶出栈；否则直接突出方法返回空。如果前面没有直接退出方法，则最后判断栈是否为空。  * @author sheepmu  */public class Stack_KuoHao { public static void main(String[] args){    System.out.println(isMach("(3+( 5*3-1)- [1+(3-5)]}")); }    public static boolean isMach(String input ){   final char LEFT_S='(';   final char LEFT_M='[';   final char LEFT_L='{';   final char RIGHT_S=')';   final char RIGHT_M=']';   final char RIGHT_L='}';       Stack<Character> stack=new  Stack<Character>();   int len=input .length();   char[] str_c=new char[len];   for(int i=0;i<len;i++)   str_c[i]= input .charAt(i)  ;      for(int i=0;i<len;i++){   switch( str_c[i]){   case LEFT_S:   case LEFT_M:   case LEFT_L:     stack.push( str_c[i]);   System.out.println("进栈字符-->   "+str_c[i]);   break;   case RIGHT_S:   if(!stack.isEmpty()&&stack.peek()==LEFT_S){    System.out.println("出栈字符-s->   "+str_c[i]);   stack.pop();}  else //如果1.栈为空;2.栈不为空但是与栈顶不匹配！  return false;//这个return直接退出方法。     break;   case RIGHT_M:       if(!stack.isEmpty()&&stack.peek()==LEFT_M) {   System.out.println("出栈字符-m->   "+str_c[i]);   stack.pop();   }   else       return false;    break;   case RIGHT_L:       if(!stack.isEmpty()&&stack.peek()==LEFT_L) {   System.out.println("出栈字符-l->   "+str_c[i]);   stack.pop();}   else       return false;    break;   }   }          return stack.isEmpty();  //若前面没有return方法，则一直执行到最后并执行此方法。   }}  

第2题：计算  3.8/2+222/(23-21)-45*2

package com.sheepmu.text;import java.util.ArrayList;import java.util.Stack;   /*   计算  3.8/2+222/(23-21)-45*2   * 思路：1.中缀表达式--->后缀表达式   *           2.计算后缀表达式。  * @author sheepmu  */public class Stack_KuoHao {enum OperatorEnum{add("+"),sub("-"),mul("*"),div("/"),leftkh("("),rightkh(")");//最后一个必须是分号。 private String value; public String getValue(){ return value; } OperatorEnum(String s){ value=s; }} public static void main(String[] args){ String s0="3.8/2+222/(23-21)-45*2";  System.out.println("原表达式---> "+s0); ArrayList<String> list_in=toArray(s0); System.out.println("中缀表达式ArrayList---> "+ list_in); Stack<String> stack_post= toPostfix(list_in);   System.out.println("后缀表达式栈---> "+ stack_post); double result=calculatePost(stack_post); System.out.println("结果---> "+ result); }   public static ArrayList<String> toArray(String input){//用ArrayList和数组相比的好处 int len=input.length(); ArrayList<String> list=new ArrayList<String>();       for(int i=0;i<len;){//!!!!!不能直接i++,因为不是每个字符为一个，因为数字可能多位数。!!!!!    String ch=String.valueOf(input.charAt(i));    if(ch.equals(OperatorEnum.add.getValue())||ch.equals(OperatorEnum.sub.getValue())||    ch.equals(OperatorEnum.mul.getValue())||ch.equals(OperatorEnum.div.getValue())||    ch.equals(OperatorEnum.leftkh.getValue())||ch.equals(OperatorEnum.rightkh.getValue())){       list.add(ch);//如果遇到操作符则直接放入数组中，       i++;       }    else{//如果非操作符，则就要判断这个数有几位数，因为不全是个位数，可能是多位数或者带有小数点。       int end=getEnd(input, i);      list.add(input.substring(i, end)) ;       i=end;        }     }       return list; }       public static int getEnd(String s,int i){   int result_end=i;   for(int j=i;j<s.length();j++){   String ch=String.valueOf(s.charAt(j));   if(ch.equals(OperatorEnum.add.getValue())||ch.equals(OperatorEnum.sub.getValue())||   ch.equals(OperatorEnum.mul.getValue())||ch.equals(OperatorEnum.div.getValue())||   ch.equals(OperatorEnum.leftkh.getValue())||ch.equals(OperatorEnum.rightkh.getValue())){   result_end=j;   break;//一旦遇到操作符就说明这个数结束，跳出循环。   }   else if(j==s.length()-1){//         !!!!!!!!!!!!!!!!若没有遇到操作符，即最后一个数!!!!!!!!!!   result_end=s.length();//上面一定是s.length()-1,这儿一定是= s.length()；不然会导致上面循环结束不了。   }   }   return  result_end;   }         public static Stack<String> toPostfix(ArrayList<String> infix){   Stack<String> stack=new Stack<String>();//放操作符的栈   Stack<String> stack_post=new Stack<String>();//把后缀表达式存在栈里比较好，方便后面运算。   int len=infix.size();    for(int i=0;i<len;i++){      if(infix.get(i).equals(OperatorEnum.leftkh.getValue())){//若果是反括号;直接进操作符栈     stack.push(infix.get(i));   }   else if(infix.get(i).equals(OperatorEnum.add.getValue())||infix.get(i).equals(OperatorEnum.sub.getValue())||   infix.get(i).equals(OperatorEnum.mul.getValue())||infix.get(i).equals(OperatorEnum.div.getValue())){   //若是加减乘除，则先判断操作符栈是否为空，否则比较运算级别。若扫描到的比操作符栈顶的低，操作符栈顶出来，   //继续比较出了栈顶后的新栈顶是否比扫描到的高或等！！！while~~~~      if(!stack.isEmpty()){//栈不为空则比较   if(compare(stack.peek(),infix.get(i))){ //若栈顶>=扫描到的  !!!应该是while而不是if,因为有可能连着几个都比他高   while(!stack.isEmpty()&&compare(stack.peek(),infix.get(i)))// !!!!!!!!stack.isEmpty()  ！！！！！！！！！！！！！   stack_post.push(stack.pop());        stack.push(infix.get(i));}        else if(!compare(stack.peek(),infix.get(i)))   stack.push(infix.get(i));   }   else{//栈为空则直接进栈 ！！！！！！！！！！！   stack.push(infix.get(i));   }   }   else if(infix.get(i).equals(OperatorEnum.rightkh.getValue())){//如果扫描到右括号     if(!stack.isEmpty()){   while(!stack.peek().equals(OperatorEnum.leftkh.getValue())){   stack_post.push(stack.pop()) ;   }   stack.pop();//把左括号弹出栈，不要了。   }   }    else {//非运算符       stack_post.push(infix.get(i));   }   }   if(!stack.isEmpty()){//若果读完了栈中还有运算符，这一个个的出栈并加到后缀表达式中   while(!stack.isEmpty())   stack_post.push(stack.pop());   }   System.out.println("临时存放中缀数组操作符的栈---->"+stack);   return stack_post;      }      public static boolean compare(String stackpeek,String ch){   if(stackpeek.equals(OperatorEnum.mul.getValue())||stackpeek.equals(OperatorEnum.div.getValue())){   if(ch.equals(OperatorEnum.add.getValue())||ch.equals(OperatorEnum.sub.getValue())||   ch.equals(OperatorEnum.mul.getValue())||ch.equals(OperatorEnum.div.getValue())){   return true;//栈顶等级>=扫描到的元素----->把栈顶弹出并放到后缀表达式中，扫描到的进栈   }   }   if(stackpeek.equals(OperatorEnum.add.getValue())||stackpeek.equals(OperatorEnum.sub.getValue())){   if(ch.equals(OperatorEnum.add.getValue())||ch.equals(OperatorEnum.sub.getValue()))   return true;   }    return false;   }   /**    * 中缀栈计算思路：1.建个新栈存放中缀表达式栈中遍历到的操作数，若遍历到的是操作数直接放进新栈；若遍历到操作符，则取出    * 新栈中的两个栈顶元素执行遍历到的操作符的运算，并把计算结果放到新栈顶，原中缀表达式栈继续遍历。    * 最后新栈表达式中的那唯一的一个数字即最后答案    */   public static double calculatePost(Stack<String> postfix){   Stack<String> newStack=new Stack<String>();   for(String s:postfix){   if(s.equals(OperatorEnum.add.getValue())||s.equals(OperatorEnum.sub.getValue())||   s.equals(OperatorEnum.mul.getValue())||s.equals(OperatorEnum.div.getValue())){   String p=s;   String d2= newStack.pop() ;   String d1= newStack.pop() ;   double result_temp=caltwo(d1,d2,p);   newStack.push(result_temp+"");   }   else{//读到的是数据   newStack.push(s);      }   }   return Double.valueOf(newStack.pop());   }   public static double caltwo(String s1,String s2,String perator){   double result=0;   double d1=Double.valueOf(s1);   double d2=Double.valueOf(s2);   switch( perator){//switch里面居然可以String     jdk1.7后就可以咯！   case "+":   result=d1+d2;   break;   case "-":   result=d1-d2;   break;   case "*":   result=d1*d2;   break;   case "/":   result=d1/d2;   break;   }   return result;   }}