使用堆栈结构进行字符串表达式("7*2-5*3-3+6/3")的计算

问题：

给定字符串String str = "7*2-5*3-3+6/3"， 求出字符串里面表达式的结果？

像javascript有自带的eval()方法，可以直接计算。但java或其它语言，API并没有提供直接计算的方法(可能是我孤陋寡闻)，这时就需要我们自己写方法实现了。

栈：

要实现上述功能，需要用到堆栈的概念，

栈是一种特殊的串行形式的数据结构，它的特殊在于，只能在队列的一端进行输入和输出，因此按照"先入后出"的原理运行。就像一个盒子，先放进的东西在下面，后面放进的东西反而在上面。如上图，栈可以看成是一个"倒立的数组"。有一个top索引，永远指向最上面一个节点。当加入一个元素时，top往上移一位。取走一个元素时，top往下移一位。当栈为空时，top指向栈的下方，top=-1.

根据上面的结构，我们可以自定义一个栈，并实现入栈(push)和弹栈(pop)两个方法：

1.入栈：将数据放入堆栈的顶端，top索引+1.

2.弹栈：将栈顶数据输出，top索引-1.

/**
 * 使用数组模拟栈
 * @author SCOTT
 *
 */
public class MyStack {
    
    private int top = -1; //指向栈顶的索引
    private int maxSize = 100; //栈所能存储的最大个数
    private Object[] array = new Object[maxSize];    //数组
    
    /**
     * 加入一个元素
     * @param val
     */
    public void push(Object val){
        if(top == maxSize - 1){
            System.out.println("栈满");
            return;
        }
        array[++top] = val;
    }
    
    /**
     * 弹出一个元素
     * @return
     */
    public Object pop(){
        if(top == -1){
            System.out.println("栈空");
            return null;
        }
        return array[top--];
    }
    
    /**
     * 遍历
     */
    public void toList(){
        for(int i=top;i>-1;i--){
            System.out.println(i+"="+array[i]);
        }
    }
    
    /**
     * 判断栈是否为空
     * @return
     */
    public boolean isEmpty(){
        if(top == -1)
            return true;
        return false;
    }
    
    /**
     * 获取栈顶的元素，跟pop()方法的区别在于：pop()方法的top索引会减1，而getTop不会
     */
    public Object getTop(){
        if(top == -1)
            return null;
        return array[top];
    }
}

对栈有了了解之后，就可以计算：String str = "7*2-5*3-3+6/3".

思路：

1.初始化两个栈，一个数栈(存放表达式中的数字)，一个符号栈(用来存储表达式中的符号).

2.遍历字符串str，将字符一个个取出进行判断，假定用ch存储取出的字符.

　　2.1.如果ch为数字，直接将数字放入数栈(这是一种抽象的说法，如果存在像700这种两位以上的数字，需要自己拼接，然后再一起入栈，只占一个位置).

　　2.2.如果ch为符号.

　　　　2.2.1.如果符号栈为空，就直接将符号放入符号栈.

      　  2.2.2.如果符号栈不为空， 就判断当前符号(ch)的运算级别跟符号栈栈顶的符号(放在符号栈最上面的一个运算符)运算级别谁大谁小?

　　　　　　2.2.2.1 循环判断，如果当前符号(ch)的优先级<=符号栈栈顶运算符的优先级，则进行计算。计算方式：从数栈中弹出两个数，和符号栈弹出一个符号，进行计算并得到结果res，将res再放入数栈。直到当前运算符的优先级>符号栈栈顶运算符的优先级为止。

　　　　　　2.2.2.2 将当前符号(ch)加入符号栈.

3.到此，已经将字符串str遍历完毕。然后再将数栈和符号栈的数据取出进行计算。计算的方式：先从数栈取出两个数，再从符号栈弹出符号，计算并得到结果res，然后将res放入数栈。依次循环，直到符号栈为空为止。

4.计算完毕后，在数栈会存在一个唯一的值，这个值就是我们需要的结果。

具体实现：

/**
 * 计算字符串表达式
 * @author SCOTT
 *
 */
public class StackApp {

    public static void main(String[] args) {
        
        String str = "7*2-5*3-3+6/3";
        //str的索引，默认指向第一位
        int index = 0;
        //用于拼接连续数字
        String tempStr = "";
        //数栈
        MyStack numStatck = new MyStack();
        //符号栈
        MyStack operStatck = new MyStack();
        
        while(true){
            char ch = str.charAt(index);
            if(isNum(ch)){
                //先进行拼接，满足条件，在放入数栈
                tempStr += ch;
                //如果到了字符串末尾，或者下一位是符号，则放入数栈
                if(index == str.length() - 1 || !isNum(str.charAt(index+1))){
                    numStatck.push(tempStr);
                }
            }else{
                tempStr = "";
                if(operStatck.isEmpty()){
                    //如果符号栈为空，则直接将运算符放入符号栈
                    operStatck.push(ch);
                }else{
                    //循环判断：如果当前运算符的级别<=栈顶运算符的级别，则计算
                    while(!operStatck.isEmpty() && getLevel(ch+"") <= getLevel(operStatck.getTop().toString())){
                        int res = calculate(numStatck, operStatck);
                        //将res入数栈
                        numStatck.push(res);
                    }
                    //将符号放入符号栈
                    operStatck.push(ch);
                }
            }
            
            index++;
            //判断条件，break
            if(index == str.length())
                break;
        }
        
        //遍历完成后，进行计算
        while(!operStatck.isEmpty()){
            int res = calculate(numStatck, operStatck);
            //将运算结果放入数栈
            numStatck.push(res);
        }
        
        //最后在数栈肯定会存在唯一的结果
        System.out.println(numStatck.pop());//-2
        
    }
    
    /**
     * 判断截取位，是否是数字
     * @param ch
     * @return
     */
    public static boolean isNum(char ch){
        if(ch == '+' || ch == '-' || ch == '*' || ch == '/')
            return false;
        return true;
    }
    
    /**
     * *和/级别为1，+和-级别为0
     * @return
     */
    public static int getLevel(String oper){
        if("*".equals(oper) || "/".equals(oper))
            return 1;
        return 0;
    }
    
    /**
     * 计算结果：//从数栈中取出两位，从符号栈中取出一位
     * @param numStatck
     * @param operStatck
     * @return
     */
    public static int calculate(MyStack numStatck, MyStack operStatck){
        int num1 = 0;
        if(numStatck.getTop() != null)
            num1 = Integer.parseInt(numStatck.pop().toString());
        int num2 = 0;
        if(numStatck.getTop() != null){
            num2 = Integer.parseInt(numStatck.pop().toString());
        }
        String str = "";
        if(operStatck.getTop() != null){
            str = operStatck.pop().toString();
        }
        
        int res = 0;
        switch (str.charAt(0)) {
            case '+':
                res = num1 + num2;
                break;
            case '-':
                res = num2 - num1;//注意顺序，栈是先入后出的结构
                break;
            case '*':
                res = num1 * num2;
                break;
            case '/':
                res = num2 / num1;//注意顺序，栈是先入后出的结构
                break;
            default:
                throw new RuntimeException("运算符不正确");
        }
        
        return res;
    }
}

上面的步骤，并没有实现带有()、[]、{}的复杂运算，还有待后续研究.