Java-表达式求值

最新推荐文章于 2024-04-28 16:55:14 发布

原创最新推荐文章于 2024-04-28 16:55:14 发布 · 550 阅读

1 ·

CC 4.0 BY-SA版权

Java 同时被 3 个专栏收录

162 篇文章

订阅专栏

Java-数据结构

33 篇文章

订阅专栏

数据结构

10 篇文章

订阅专栏

本文介绍了一种使用栈数据结构实现表达式计算的方法。通过定义泛型栈类NewStack，结合Calculation类中的计算逻辑，可以解析并计算复杂的数学表达式。文章详细展示了如何处理括号、操作符优先级及数字的读取。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

代码

NewStack.java


import java.util.LinkedList;
/**
 * 泛型栈
 * @author 焦焱-16060211104
 *
 * @param <T> 需要存储的类型
 */
public class NewStack<T> {
private LinkedList<T> St = new LinkedList<T>(); //存数据
/**
 * 入栈
 * @param e 数据
 */
public void push(T e)
{
    St.addFirst(e);
}
/**
 * 出栈
 * @return 数据
 */
public T Pop()
{
    if(empty())
    {
        System.out.println("栈空");
        return null;
    }else
    return St.removeFirst();
}
/**
 * 判断是否为空栈
 * @return true或者false
 */
public boolean empty()
{
    return St.isEmpty();
}
/**
 * 获得栈顶元素
 * @return 数据
 */
public T Top()
{
    if(empty())
    {
        System.out.println("栈空");
        return null;
    }else
    return St.getFirst();
}
/**
 * 返回当前栈中元素数目
 * @return
 */
public int Num()
{
    return St.size();
}
}

Calculation.java

package ThreeOne;
/**
 * 计算类
 * @author 焦焱-16060211104
 *进行计算
 */
public class Calculation {
static void Calculate(String a)
{   char temp;
    double f;
    /**
     * 一个符号栈一个数据栈
     */
    NewStack<Character> optr = new NewStack<Character>();
    NewStack<Double> opnd = new NewStack<Double>();
    optr.push('#');
    for(int i=0;i<a.length();i++)
    {   //用来转化数字
        StringBuilder num = new StringBuilder();
        switch (a.charAt(i))
        {
        /*进行优先级判断，如果高于栈顶元素则入栈，负责进行计算，然后将结果压入操作数栈，
         当前操作符添加到操作符栈
        */
        case '+':
        case '-':
            temp = optr.Top();
            if(temp=='#'||temp=='(')
            {
                optr.push(a.charAt(i));
            }
            else
            {
                double One = opnd.Pop();
                double Two = opnd.Pop();
                char Three = optr.Pop();
                opnd.push(Operation(Two, One, Three));
            }
            break;
        case '*':
        case '/':
            temp = optr.Top();
            if(Rank(a.charAt(i))>Rank(temp)|| temp == '(')
            {
                optr.push(a.charAt(i));
            }
            else
            {
                double One = opnd.Pop();
                double Two = opnd.Pop();
                char Three = optr.Pop();
                opnd.push(Operation(Two, One, Three));
            }
            break;
        case '(':
            optr.push(a.charAt(i));
            break;
        case ')':
        temp = optr.Top();
        while(temp!='(')
        {
            double One = opnd.Pop();
            double Two = opnd.Pop();
            char Three = optr.Pop();
            opnd.push(Operation(Two, One, Three));
            temp = optr.Top();
        }
        temp=optr.Pop();
            break;
        default:
        /*
         * 处理数字，并将其入栈
         */
        while(a.charAt(i)>='0'&&a.charAt(i)<='9'||a.charAt(i)=='.'){
            num.append(a.charAt(i));    
            i++;
            if(i==a.length())
                break;
            }
        i--;
            f=Double.valueOf(num.toString());
            opnd.push(f);
            break;
        }
    }
    temp = optr.Top();
    /*
     * 进行最后的计算，如果操作符栈顶不为#则运算还没全部完成
     */
    while(temp!='#')
    {
        double One = opnd.Pop();
        double Two = opnd.Pop();
        char Three = optr.Pop();
        opnd.push(Operation(Two, One, Three));
        temp = optr.Top();
    }
    double result = opnd.Top();
    System.out.println(result);
}
/**
 * 划分优先级
 * @param e 当前操作符
 * @return 操作符优先级数
 */
private static int Rank(char e)
{
    switch (e) {
    case '#':
        return 0;
    case '(':
        return 1;
    case '+':
    case '-':
        return 2;
    case '*':
    case '/':
        return 3;
    default:
        return -1;
    }
}
/**
 * 运算
 * @param a
 * @param b
 * @param c
 * @return
 */
private static double Operation(double a,double b,char c)
{
    double d=-1;
    switch (c) {
    case '+':
        d= a+b;
        break;
    case '-':
        d=a-b;
        break;
    case '*':
        d=a*b;
        break;
    case '/':
        if(b==0){
            System.out.println("分母为0");
            return -1;
        }
        else
        d=a/b;
        break;
    default:
        System.out.println("输入的字符不合法");
        break;
    }
    return d;
}
}

Test.java


import java.util.Scanner;

public class Test {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String a = "(1+2)*(4/2)";
Calculation.Calculate(a);
}
}

结果

这里写图片描述