栈-----括号匹配+表达式计算
第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;
}
}
