栈应用_四则运算

题目

输入字符串格式的算术表达式，如: “3+2*{1+2*[-4/(8-6)+7]}”；输出去结果。

思路

栈的应用；
四则运算分为下列四个过程

1. 读取字符串 （并不是简单地读入，比如 当字符串中有两位数，例如12时，我们应该读成 “12”而不是“1”，“2”，不然运算会出现错误）。
2. 处理字符串，给字符串加0 （为了保证后缀运算的正常运行，需要对出现的负数进行考虑。 例如 （-4 + 3） 为了运算正确，将其处理成（0 - 4 +3））
3. 将中缀表达式转化成后缀表达式
4. 计算后缀表达式

代码

public class Main {
    static Scanner sc = new Scanner(System.in);

    public static void main(String[] args) {
        String s = sc.nextLine();
        // 将各种括号统一替换成小括号
        s = s.replaceAll("\\{","(");
        s = s.replaceAll("\\[","(");
        s = s.replaceAll("\\}",")");
        s = s.replaceAll("\\]",")");

        char[] chars = s.toCharArray();
        // 读取字符串
        List<String> all = new ArrayList<>();

        int len = s.length();
        int i=0;
        while(i<len){
            int offset = 0;
            while(i+offset<len && (chars[i+offset]>='0'&&chars[i+offset]<='9')){
                offset++;
            }
            if(offset != 0){
                all.add(String.valueOf(chars,i,offset));
                i+=offset;
            }else{
                all.add(String.valueOf(chars,i,1));
                i++;
            }
        }

        // 给字符串加 0
        List<String> list = new ArrayList<>();
        for(int j=0; j<all.size(); j++){
            if(all.get(j).equals("-")){
                if(j == 0){
                   list.add("0");
                }else{
                    if(all.get(j-1).equals("(")){
                        list.add("0");
                    }
                }
            }
            list.add(all.get(j));
        }
        List<String> postExpre = getPostExpre(list);
        System.out.println(caculate(postExpre));

    }
    // 将中缀表达式转为后缀表达式
    public static List<String> getPostExpre(List<String> list){
    	//存数字
        List<String> post = new ArrayList<>();
        // 存操作符
        Stack<String> ops = new Stack<>();

        int len = list.size();
        for(int i=0; i<len; i++){
            String tmp = list.get(i);
            // 非数字的情况，直接加入链表
            if(!tmp.equals("(")&&!tmp.equals(")")&&!tmp.equals("+")&&!tmp.equals("-")&&
                    !tmp.equals("*")&&!tmp.equals("/")){
                post.add(tmp);
                // 左括号 乘除 直接加入操作符栈
            }else if(tmp.equals("(") || tmp.equals("*") || tmp.equals("/")){
                ops.push(tmp);
               // 遇见右括号，将前面直到左括号的弹出，左括号也要弹出
            }else if(tmp.equals(")")){
                for(int j=ops.size()-1; j>=0; j--){
                    String ch = ops.pop();
                    if(!ch.equals("(")){
                        post.add(ch);
                    }else{
                        break;
                    }
                }
            }else if(tmp.equals("+") || tmp.equals("-")){
                if(ops.size()==0 || ops.size()>1&&ops.get(ops.size()-1).equals("(")){
                    ops.push(tmp);
                }else{
                    for(int j=ops.size()-1; j>=0; j--){
                        // 左括号不需要弹出
                        String ch = ops.get(j);
                        if(!ch.equals("(")){
                            post.add(ops.pop());
                        }else{
                            break;
                        }
                    }
                    ops.push(tmp);
                }
            }
        }
        for(int j=ops.size()-1; j>=0; j--){
            post.add(ops.pop());
        }
        return post;
    }

    // 计算后缀表达式
    public static int caculate(List<String> post){
    	// 运算结果栈
        Stack<Integer> vals = new Stack<>();
        // 操作符栈
        Stack<String> ops = new Stack<>();

        int len = post.size();
        for(int i=0; i<len; i++){
            String tmp = post.get(i);
            if(!tmp.equals("+")&&!tmp.equals("-")&&!tmp.equals("*")&&!tmp.equals("/")){
                vals.push(Integer.parseInt(tmp));
            }else{
                int val = 0;
                int n1 = vals.pop();
                int n2 = vals.pop();
                if(tmp.equals("+")){
                    val = n2+n1;
                }else if(tmp.equals("-")){
                    val = n2-n1;
                }else if(tmp.equals("*")){
                    val = n2*n1;
                }else if(tmp.equals("/")){
                    val = n2/n1;
                }
                vals.push(val);
            }
        }
        return vals.pop();

    }
}