java去哪儿笔试解决方案四

请使用自己实现的stack，实现一个整型表达式求值的函数，表示式支持的运算符有（）*/+-具体说明如下

1.*/优先级高于+-

2.表达式中相同优先级的操作符自左向右计算

3.函数输入字符串"1+(4-3)*5/5",函数返回结果为2

使用api中stack

将前缀转为后缀

/**
 * 中缀表达式 转 后缀表达式
 */
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Stack;


public class ExpressConvert {  
 
    /** 
     * 优先级比较 
     * @param operator1 比较值 
     * @param operator2 被比较值 
     * @return 小于等于返回false,大于返回true 
     */  
    public boolean comparePrior(char operator1, char operator2) {  
        if('(' == operator2) {  
            return true;  
        }  
        if ('*' == operator1 || '/' == operator1) {  
            if ('+' == operator2 || '-' == operator2) {  
                return true;  
            }  
        }  
        return false;  
    }  
  
    /** 
     * 转为后缀表达式: 
     * 1、如果是"("直接压入stack栈。 
     * 2、如果是")"，依次从stack栈弹出运算符加到数组newExpressionStrs的末尾，知道遇到"("； 
     * 3、如果是非括号，比较扫描到的运算符，和stack栈顶的运算符。如果扫描到的运算符优先级高于栈顶运算符则，把运算符压入栈。否则的话，就依次把栈中运算符弹出加到数组newExpressionStrs的末尾，直到遇到优先级低于扫描到的运算符或栈空，并且把扫描到的运算符压入栈中。就这样依次扫描，知道结束为止。如果扫描结束，栈中还有元素，则依次弹出加到数组newExpressionStrs的末尾，就得到了后缀表达式。 
     * @param expressionStrs 
     * @return 
     */  
    public List<Character> toSuffixExpression(char[] expressionStrs) {  
        //新组成的表达式  
        List<Character> newExpressionStrs = new ArrayList<Character>(); 
        Stack<Character> stack = new Stack<Character>();  
        for (int i = 0; i < expressionStrs.length; i++) {  
            if ('('==(expressionStrs[i])) { // 如果是左括号,则入栈  
                stack.push(expressionStrs[i]);  
            } else if ('+'==expressionStrs[i] || '-' == expressionStrs[i] || '*' == expressionStrs[i] || '/' == expressionStrs[i]) {  
           
                if (!stack.empty()) { // 取出先入栈的运算符  
                Character s = stack.pop();  
                    if(comparePrior(expressionStrs[i], s)) { //如果栈值优先级小于要入栈的值,则继续压入栈  
                        stack.push(s);  
                    } else {  //否则取出值  
                        newExpressionStrs.add(s);  
                    }  
                } 
                
                stack.push(expressionStrs[i]);  
            } else if (')' == expressionStrs[i]) { //如果是')',则出栈,一直到遇到'('  
                while (!stack.empty()) {  
                    char s = stack.pop();  
                    if (!('(' == s)) {  
                        newExpressionStrs.add(s);  
                    } else { 
                        break;  
                    }  
                }  
            } else {  
                newExpressionStrs.add(expressionStrs[i]);  
            }  
        }  
        while (!stack.empty()) {  
            char s = stack.pop();  
            newExpressionStrs.add(s);  
        }  
        return newExpressionStrs;  
    }  
  
    public static void main(String[] args) {  
 
    String expressionStr = "5+(4-5+1)-4+(6-5+3)+2";
    // 分割成表达式数组 
    char []expressionChrs = expressionStr.toCharArray();
        
        List<Character> newExpressionStrs = new ExpressConvert().toSuffixExpression(expressionChrs);  
        Iterator<Character> iter = newExpressionStrs.iterator();
        while(iter.hasNext()){
        System.out.print(iter.next());
        }
    }  
}  

//用栈计算后缀表达式值

原理：将后缀表达只放在list中，或者数组

循环去除后缀表达式如果取出的为数字则push到stack中，如果是运算符，则将stack中的数值pop出来，用后pop出的数（+-*/）先pop出的数，然后将结果放回stack中

直到最后一个值pop出stack，即为所求

import java.util.Iterator;
import java.util.List;


import calculator.ExpressConvert;
import dataStructure.MyStack;


public class Test4 {




public static void main(String []args){
MyStack ms = new MyStack();
String str = "1+(4-3)*5/5";
char chr[] = str.toCharArray();
ExpressConvert ec = new ExpressConvert();
List<Character> list = ec.toSuffixExpression(chr);
Iterator<Character> iter = list.iterator();
while(iter.hasNext()){
Character c = iter.next();
try {
if(c=='+' || c == '-' || c == '*' || c == '/'){

int a = Integer.parseInt(ms.pop().toString());
int b = Integer.parseInt(ms.pop().toString());


int n = 0;
                    switch(c){

case '+':n=b+a;break;
case '-':n=b-a;break;
case '*':n=b*a;break;
case '/':n=b/a;break;
}

                    ms.push(n);
}else{
ms.push(c);
}

} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println(ms.getSize());
try {
System.out.println(ms.pop());
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
} e.printStackTrace();
}
}
}

//自定义栈 （简单的） 欢迎吐槽

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;


/**
 * 数据结构 栈
 * 使用数组实现
 * @author Administrator
 *
 */
public class MyStack<T> {


private int top ;//栈顶
private Object[] obj;
private int max=10;
private int size;//栈大小
public MyStack(){
this.obj = new Object[max];
}
public boolean empty(){
if(size == 0)
return true;
return false;
}
public T pop() throws Exception{

if(size==0) throw new Exception("下表越界");
Object objct = obj[top];
obj[top--] = null;

size --;
return (T)objct;
}
public T push(Object o) throws Exception{
if(size==max) throw new Exception("下标越界");
obj[++top] = o;
size ++;
return (T)obj[top];
}
public int getSize(){
return size;
}
public static void main(String []args){
MyStack ms = new MyStack();
try {
ms.push("aaa");
ms.push("bbb");
ms.push("ccc");
System.out.println(ms.pop()+" "+ms.pop());
System.out.println(ms.size);
System.out.println(1+(4-3)*5/5);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

//使用自定义stack，前缀转中缀

/**
 * 中缀表达式 转 后缀表达式
 */
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;


import dataStructure.MyStack;


public class ExpressConvert {  
 
    /** 
     * 优先级比较 
     * @param operator1 比较值 
     * @param operator2 被比较值 
     * @return 小于等于返回false,大于返回true 
     */  
    public boolean comparePrior(char operator1, char operator2) {  
        if('(' == operator2) {  
            return true;  
        }  
        if ('*' == operator1 || '/' == operator1) {  
            if ('+' == operator2 || '-' == operator2) {  
                return true;  
            }  
        }  
        return false;  
    }  
  
    /** 
     * 转为后缀表达式: 
     * 1、如果是"("直接压入stack栈。 
     * 2、如果是")"，依次从stack栈弹出运算符加到数组newExpressionStrs的末尾，知道遇到"("； 
     * 3、如果是非括号，比较扫描到的运算符，和stack栈顶的运算符。如果扫描到的运算符优先级高于栈顶运算符则，把运算符压入栈。否则的话，就依次把栈中运算符弹出加到数组newExpressionStrs的末尾，直到遇到优先级低于扫描到的运算符或栈空，并且把扫描到的运算符压入栈中。就这样依次扫描，知道结束为止。如果扫描结束，栈中还有元素，则依次弹出加到数组newExpressionStrs的末尾，就得到了后缀表达式。 
     * @param expressionStrs 
     * @return 
     */  
    public List<Character> toSuffixExpression(char[] expressionStrs){  
        //新组成的表达式  
        List<Character> newExpressionStrs = new ArrayList<Character>(); 
        MyStack<Character> MyStack = new MyStack<Character>();  
        try {
for (int i = 0; i < expressionStrs.length; i++) {  
   if ('('==(expressionStrs[i])) { // 如果是左括号,则入栈  
      
MyStack.push(expressionStrs[i]); 
   } else if ('+'==expressionStrs[i] || '-' == expressionStrs[i] || '*' == expressionStrs[i] || '/' == expressionStrs[i]) {  
   
       if (!MyStack.empty()) { // 取出先入栈的运算符  
        Character s = MyStack.pop();  
           if(comparePrior(expressionStrs[i], s)) { //如果栈值优先级小于要入栈的值,则继续压入栈  
               MyStack.push(s);  
           } else {  //否则取出值  
               newExpressionStrs.add(s);  
           }  
       } 
       
       MyStack.push(expressionStrs[i]);  
   } else if (')' == expressionStrs[i]) { //如果是')',则出栈,一直到遇到'('  
       while (!MyStack.empty()) {  
           char s = MyStack.pop();  
           if (!('(' == s)) {  
               newExpressionStrs.add(s);  
           } else { 
               break;  
           }  
       }  
   } else {  
       newExpressionStrs.add(expressionStrs[i]);  
   }  
}  
while (!MyStack.empty()) {  
   char s = MyStack.pop();  
   newExpressionStrs.add(s);  
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}  
        return newExpressionStrs;  
    }  
  
    public static void main(String[] args) {  
 
    String expressionStr = "5+(4-5+1)-4+(6-5+3)+2";
    // 分割成表达式数组 
    char []expressionChrs = expressionStr.toCharArray();
        
        List<Character> newExpressionStrs;
try {
newExpressionStrs = new ExpressConvert().toSuffixExpression(expressionChrs);
Iterator<Character> iter = newExpressionStrs.iterator();
       while(iter.hasNext()){
        System.out.print(iter.next());
       }
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}  
        
    }  
}  

//计算

public class Test4 {




public static void main(String []args){
MyStack ms = new MyStack();
String str = "1+(5-3)*5/5";
char chr[] = str.toCharArray();
ExpressConvert ec = new ExpressConvert();
List<Character> list = ec.toSuffixExpression(chr);
Iterator<Character> iter = list.iterator();
while(iter.hasNext()){
Character c = iter.next();
try {
if(c=='+' || c == '-' || c == '*' || c == '/'){

int a = Integer.parseInt(ms.pop().toString());
int b = Integer.parseInt(ms.pop().toString());


int n = 0;
                    switch(c){

case '+':n=b+a;break;
case '-':n=b-a;break;
case '*':n=b*a;break;
case '/':n=b/a;break;
}

                    ms.push(n);
}else{
ms.push(c);
}

} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println(ms.getSize());
try {
System.out.println(ms.pop());
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}