算法之栈实现字符串运算

用栈实现 3+2*6-2 思路图解 7*2*2-5+1-5+3-4
定义两个栈，一个栈存数字，一个栈存运算符
循环字符串中的每一位
表达式扫描
1. 如果是数字，直接入数栈
2.如果是运算符，判断优先级
若运算符>栈中的运算符，直接入栈
若运算符<=栈中的运算符，符号栈pop一个符号栈，从数字栈pop两个数进行运算，将结果入数栈，然后运算符入符号栈

表达工扫描完毕
符号栈pop一个符号栈，从数字栈pop两个数进行运算，将结果入数栈

 

 验证分析过程：

----读取3，直接入数栈

数字栈  3   

---读取+，数字栈为空，直接入栈

此时栈内容为：数字栈  3   ====   符号栈 +

---读取2，，直接入数栈

此时栈内容为：数字栈 2  3   ====  符号栈 +

---读取*，从符号栈取出(注意不是出栈)+进行比较，*优先级大于+，直接入栈

此时栈内容为：数字栈 2  3   ====  符号栈 *  +

---读取6，直接入数栈

此时栈内容为：数字栈 6 2  3   ====  符号栈 *  +

---读取-，从符号栈取出(注意不是出栈)*进行比较，-优先级小于*，从数字栈弹出两个值，从符号栈弱弹出一个运算符*进行运算，即6*2=12

此时栈内容为：数字栈  3   ====  符号栈 +

然后将运算结果入数字栈，并将运算符-入栈

此时栈内容为：数字栈 12  3   ====  符号栈 -  +

---读取2，直接入数字栈

此时栈内容为：数字栈 2 12  3   ====  符号栈 -  +

至此  表达式读取完毕，接下来分别从数字栈弹出两个值2和12，从符号栈弱弹出一个运算符-进行运算，即12-2=10，并将运算结果入数字栈

此时栈内容为：数字栈 10  3   ====  符号栈 +

接下来分别从数字栈弹出两个值10和3，从符号栈弱弹出一个运算符 + 进行运算，即10+3=13，并将运算结果入数字栈

此时数字栈内容为13，符号栈为空，运算结束

代码如下：

package azhong.stack;

/**
 * 用栈实现 3+2*6-2 思路  7*2*2-5+1-5+3-4=28-14+4=18
 * 定义两个栈，一个栈存数字，一个栈存运算符
 * 循环字符串中的每一位
 * 表达式扫描
 * 1. 如果是数字，直接入数栈
 * 2.如果是运算符，判断优先级
 *     若运算符>栈中的运算符，直接入栈
 *     若运算符<=栈中的运算符，从符号栈弹出一个符号，从数字栈pop两个数进行运算，将结果入数栈，然后运算符入符号栈
 * 表达式扫描完毕
 * 符号栈pop一个符号栈，从数字栈pop两个数进行运算，将结果入数栈
 */
public class StringComputeDemo {
    public static void main(String[] args) {
        StringComputer computer = new StringComputer();
        String str ="7*2*2-5+1-5+3-4";
        int result = computer.doString(str);
        System.out.println(str+"="+result);
    }
}
class StringComputer{
    NumberStack numberStack = new NumberStack(10);
    ComputeStack computeStack = new ComputeStack(10);
    public int  doString(String str){
        String[] strArr = str.split("");
        for(String s:strArr){
            if(isOperate(s)){
                //是操作符
                //System.out.println("操作符："+s);
                if(computeStack.top==-1){
                    //如果为空，直接入栈
                    computeStack.push(s);
                }
                else{
                    //从运算符栈中取出一个进行比较
                    String operateFromStack = computeStack.get();
                    int level_stack = getOperateLevel(operateFromStack);
                    int level = getOperateLevel(s);
                    //若运算符>栈中的运算符，直接入栈
                    if(level>level_stack){
                        computeStack.push(s);
                    }
                    else{
                        //从符号栈弹出一个符号，从数字栈pop两个数进行运算，将结果入数栈，然后运算符入符号栈
                        String strOperateFromStack =computeStack.pop();
                        int num1 =numberStack.pop();
                        int num2=numberStack.pop();
                        int n =compute(num1,num2,strOperateFromStack);
                        //运算结果入数栈
                        numberStack.push(n);
                        //操作符入符号栈
                        computeStack.push(s);
                    }
                }
            }
            else{
                //是数字
                //System.out.println("数字："+s);
                int val = Integer.valueOf(s);
                numberStack.push(val);
            }
        }
        //表达式扫描完毕 进行运算
        while (true){
            if(computeStack.isEmpty()){
                break;
            }
            String operate =computeStack.pop();
            int n1 =numberStack.pop();
            int n2=numberStack.pop();
            int val =compute(n1,n2,operate);
            numberStack.push(val);
        }
        //运算完毕，取结果
        return numberStack.pop();
    }

    private int compute(int n1,int n2,String operate){
        if(operate.equals("+")){
            return n1+n2;
        }
        else if(operate.equals("-")){
            return n2-n1;
        }
        else if(operate.equals("*")){
            return n1*n2;
        }
        else if(operate.equals("/")){
            return n2/n1;
        }
        else{
            return 0;
        }
    }

    public boolean isOperate(String val){
        String str="+-*/";
        int i = str.indexOf(val);
        return i>=0;
    }
    public int getOperateLevel(String val){
        if("*/".indexOf(val)>=0){
            return 1;
        }
        else if("+-".indexOf(val)>=0){
            return 0;
        }
        else{
            return -1;
        }
    }
}

/**
 * 数值栈
 */
class NumberStack{
    int [] arr;
    int size;
    int top;
    public NumberStack(int size){
        this.size=size;
        this.top=-1;
        arr = new int[size];
    }
    public void push(int val){
        if(!isFull()){
            top++;
            arr[top]=val;

        }
    }
    public int pop(){
        if(!isEmpty()){
            int val =arr[top];
            top--;
            return val;
        }
        return top;
    }
    private boolean isFull(){
        return top==size-1;
    }
    private boolean isEmpty(){
        return top==-1;
    }
}

/**
 * 运算符栈
 */
class ComputeStack{
    String[] arr;
    int top;
    int size;
    public ComputeStack(int size){
        this.size=size;
        top=-1;
        arr = new String[size];
    }
    public void push(String val){
        if(!isFull()){
            top++;
            arr[top]=val;

        }
    }
    public String pop(){
        if(!isEmpty()){
            String val =arr[top];
            top--;
            return val;
        }
        return null;
    }

    public String get(){
        return arr[top];
    }
    private boolean isFull(){
        return top==size-1;
    }
    public boolean isEmpty(){
        return top==-1;
    }
}