JAVA语言实现四则运算和pad图展示

LYF13876861623

已于 2024-04-09 09:27:49 修改

阅读量186

点赞数 4

文章标签： java 算法开发语言

于 2024-04-09 09:02:24 首次发布

本文链接：https://blog.csdn.net/LYF13876861623/article/details/137535442

版权

本文介绍了如何通过编程将四则运算转换为后缀表达式，利用栈数据结构处理加、减、乘、除操作，详细展示了在Java中的实现过程。

摘要由CSDN通过智能技术生成

四则运算是指加法、减法、乘法和除法四种运算，例如：1+(2-3/4)*5 。我们可以很快得到答案，但如何通过编程实现其运算呢？


//四则运算
public class FourFundamentalRules {
    private static Stack<Character> stack = new Stack<>();//后缀表达式
    private static Stack<Character> stack_1 = new Stack<>();//符号栈
    private static Stack<Character> stack_2 = new Stack<>();//临时栈
    public static void main(String[] args) {
        String str = "1+(2-3/4)*5";
        try {
            Double b = calculate(str);
            System.out.println("运算结果为："+b);
        }catch (Exception e){
            System.out.println("error");
        }
    }
    //运算
    private static Double calculate(String str) throws Exception{
        char[] arr = str.toCharArray();
        //转化为后缀表达式
        for(int i=0;i<arr.length;i++){
            if(Character.isDigit(arr[i])){//判断是否为数字
                stack.push(arr[i]);
            }else if(arr[i] == '*'||arr[i] == '/'){
                while(!stack_1.empty()){
                    char ch = stack_1.pop();
                    if(ch == '('){
                        stack_1.push(ch);
                        break;
                    }else if(ch == '*' || ch == '/'){
                        stack.push(ch);
                    }else{
                        stack_2.push(ch);
                    }
                }
                while(!stack_2.empty()){
                    stack_1.push(stack_2.pop());
                }
                stack_1.push(arr[i]);
            } else if(arr[i] == '+'|| arr[i] == '-'){
                while(!stack_1.empty()){
                    char ch = stack_1.pop();
                    if(ch == '('){
                        stack_1.push(ch);
                        break;
                    }else if(ch == '*' || ch == '/'||ch == '+'|| ch == '-'){
                        stack.push(ch);
                    }else{
                        stack_2.push(ch);
                    }
                }while(!stack_2.empty()){
                    stack_1.push(stack_2.pop());
                }
                stack_1.push(arr[i]);
            }else if(arr[i] == '('){
                stack_1.push(arr[i]);
            }else if(arr[i] == ')'){
                char ch = stack_1.peek();
                while(ch != '('){
                    ch = stack_1.pop();
                    stack.push(ch);
                }
                stack.pop();
            }else{
                throw new Exception();
            }
        }
        while(!stack_1.empty()){
            stack.push(stack_1.pop());
        }
        //进行运算
        while(!stack.empty()){
            stack_2.push(stack.pop());
        }
        Stack<Double> s = new Stack<>();//用于最后计算的栈
        while(!stack_2.empty()){
            char ch = stack_2.pop();
            if(ch == '*' || ch == '/'||ch == '+'|| ch == '-'){
                double sum = 0;
                double num1= s.pop();
                double num2= s.pop();
                switch (ch){
                    case '*':sum = num2*num1;break;
                    case '/':sum = num2/num1;break;
                    case '+':sum = num2+num1;break;
                    case '-':sum = num2-num1;break;
                }
                s.push(sum);
            }else if (Character.isDigit(ch)){
                s.push((double)Character.getNumericValue(ch));
            }else{
                throw new Exception();
            }
        }
        return s.pop();
    }
}