Java实现四则运算带括号和负数

题目

请实现如下接口

    /* 功能：四则运算

     * 输入：strExpression：字符串格式的算术表达式，如: "3+2*{1+2*[-4/(8-6)+7]}"

         * 返回：算术表达式的计算结果

     */

    public static int calculate(String strExpression)

    {

        /* 请实现*/

        return 0;

    } 

约束：

1. pucExpression字符串中的有效字符包括[‘0’-‘9’],‘+’,‘-’, ‘*’,‘/’ ,‘(’， ‘)’,‘[’, ‘]’,‘{’ ,‘}’。

2. pucExpression算术表达式的有效性由调用者保证; 

 

输入描述:

输入一个算术表达式

输出描述:

得到计算结果

示例1

输入

3+2*{1+2*[-4/(8-6)+7]}

输出

25

有两种常见的实现方式,这里为了简洁没有对错误输入进行判断.

1. 先将中缀表达式转化为后缀表达式(逆波兰式),然后再计算后缀表达式两个栈直接计算
2. 两栈直接计算

注意事项

• 这里一定注意负数的处理,因为这一点困惑了很久
• 在输入的表达式两端中加入 () 可以帮助 判断是否表达式结束 eg:1+1 => (1+1) 这样在遍历时可以通过括号的匹配,注意括号必须成对出现
• 先将表达式中的[] {} 替换为 () 方便计算 

package com.example;
import java.util.ArrayList;
import java.util.Scanner;
import java.util.List;
import java.util.Stack;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		String s = sc.next();	
		//System.out.println(s.substring(1));
		calculate(s);
	}
	//负数的问题
	public static int calculate(String strExpression)
    {
		String s = simplify(strExpression);
		System.out.println("s : "+s);
		String numStr = "";//记录数字
		Stack opeStack = new Stack<>();//符号站		
		int l = s.length();//字符串长度 l
		List list = new ArrayList<>();
		
		for(int i=0;i num = new Stack<>();
		int size = list.size();
		for(int i=0;i//负数的处理
		// 处理负数，这里在-前面的位置加入一个0，如-4变为0-4，
		// 细节：注意-开头的地方前面一定不能是数字或者反括号，如9-0,(3-4)-5，这里地方是不能加0的
		// 它的后面可以是数字或者正括号，如-9=>0-9, -(3*3)=>0-(3*3)
		String s = str.replaceAll("(?b1)
				return true;
			else
				return false;
	}
	
	/**
	 * 得到一个字符的优先级
	 * @param a
	 * @return
	 */
	public static int getLevel(char a)
	{

		if(a=='+')
			return 0;
		else if(a=='-')
			return 1;
		else if(a=='*')			
			return 3;
		else if(a=='/')
			return 4;
		else 
			return -1;

	}

	//判断是不是数字
	 public static boolean isNumeric(String str){
         Pattern pattern = Pattern.compile("[0-9]*");
         Matcher isNum = pattern.matcher(str);
         if( !isNum.matches() ){
             return false;
         }
         return true;
  }

}

方法2 两个栈直接计算

链接：https://www.nowcoder.com/questionTerminal/9999764a61484d819056f807d2a91f1e
来源：牛客网
//转自牛客网 这里我也加了一些自己的分析

public class Main{
    // 用于存放一个正括号的集合, 用于简化代码
    static Set brace = new HashSet<>();
    public static void main(String ... args){
        Scanner sc = new Scanner(System.in);
        // 初始化正括号集合 他这里处理括号的方式有些不懂,我是直接替换的    
   brace.add('{');
        brace.add('(');
        brace.add('[');
        while(sc.hasNextLine()){
            // 对字符串做初始化处理，原则有二:
            // 1、处理负数，这里在-前面的位置加入一个0，如-4变为0-4，
            // 细节：注意-开头的地方前面一定不能是数字或者反括号，如9-0,(3-4)-5，这里地方是不能加0的
            // 它的后面可以是数字或者正括号，如-9=>0-9, -(3*3)=>0-(3*3)
            // 2、处理字符串，在最后的位置加#, 主要是为了防止最后一个整数无法处理的问题
            String exp = sc.nextLine().replaceAll("(? opStack = new Stack<>();
        Stack otStack = new Stack<>();
         
        // 整数记录器  当num是多位时将 num += c 知道遇见运算符
        String num = "";
        for(int i = 0; i < exp.length(); i++){
            // 抽取字符
            char c = exp.charAt(i);
            // 如果字符是数字，则加这个数字累加到num后面
            if(Character.isDigit(c)){
                num += c;
            }
            // 如果不是数字
            else{
                // 如果有字符串被记录，则操作数入栈，并清空
                if(!num.isEmpty()){
                    int n = Integer.parseInt(num);
                    num = "";
                    opStack.push(n);
                }
                // 如果遇上了终结符则退出
                if(c == '#')
                    break;
                // 如果遇上了+-
                else if(c == '+' || c == '-'){
                    // 空栈或者操作符栈顶遇到正括号，则入栈
                    if(otStack.isEmpty() || brace.contains(otStack.peek())){
                        otStack.push(c);
                    } else {
                        // 否则一直做弹栈计算，直到空或者遇到正括号为止，最后入栈
                        while(!otStack.isEmpty() && !brace.contains(otStack.peek()))
                            popAndCal(opStack, otStack);
                        otStack.push(c);
                    }
                }
                // 如果遇上*/
                else if(c == '*' || c == '/'){
                    // 空栈或者遇到操作符栈顶是括号，或者遇到优先级低的运算符，则入栈
                    if(otStack.isEmpty()
                            || brace.contains(otStack.peek())
                            || otStack.peek() == '+' || otStack.peek() == '-'){
                        otStack.push(c);
                    }else{
                        // 否则遇到*或/则一直做弹栈计算，直到栈顶是优先级比自己低的符号，最后入栈
                        while(!otStack.isEmpty()
                                && otStack.peek() != '+' && otStack.peek() != '-'
                                && !brace.contains(otStack.peek()))
                            popAndCal(opStack, otStack);
                        otStack.push(c);
                    }
                } else {
                    // 如果是正括号就压栈
                    if(brace.contains(c))
                        otStack.push(c);
                    else{
                        // 反括号就一直做弹栈计算，直到遇到正括号为止
                        char r = getBrace(c);
                        while(otStack.peek() != r){
                            popAndCal(opStack, otStack);
                        }
                        // 最后弹出正括号
                        otStack.pop();
                    }
                }
            }
        }
        // 将剩下的计算完，直到运算符栈为空
        while(!otStack.isEmpty())
            popAndCal(opStack, otStack);
        // 返回结果
        return opStack.pop();
    }
    private static void popAndCal(Stack opStack, Stack otStack){
        int op2 = opStack.pop();
        int op1 = opStack.pop();
        char ot = otStack.pop();
        int res = 0;
        switch(ot){
            case '+':
                res = op1 + op2;
                break;
            case '-':
                res = op1 - op2;
                break;
            case '*':
                res = op1 * op2;
                break;
            case '/':
                res = op1 / op2;
                break;
        }
        opStack.push(res);
    }
    private static char getBrace(char brace){
        switch(brace){
            case ')':
                return '(';
            case ']':
                return '[';
            case '}':
                return '{';
        }
        return '#';
    }
}