数据结构 算数表达式求值

算术表达式求值
问题描述：编写程序，计算算术表达式串的值，具体要求如下：
①表达式串在运行时输入。
②表达式串支持+、-、、/（精确除）
、%（整除取余）
、圆括号等运算符，且支持任意位数的整
形常量和浮点型常量。如“33/2-(41.23+2)(52%7)”的值为“-113.19”
。
③运算符优先级依次为：括号、乘除、加减，若优先级相同，则从左至右。
④当表达式串非法时，能提示信息。

c语言的不知道，给个java的示例

#include<iostream>
#include<sstream>
#include<string>
#include<regex>
#include"Stack"

class EItem{
    public:
        int num;
        char priority;
    public:
        EItem(){}
        EItem(int num,char priority=0){
            this->num=num;
            this->priority=priority;
        }
        EItem* find(char ch){
            if((int)ch==num) return this;
            return NULL;
        }
};
EItem charItem[10];    
int calc(std::string exp){
    //if(!std::regex_match(exp,std::regex("(-?\\d+)(\\ *[+\\-*/]\\ *-?\\d+)*"))) throw 3;
    Stack<EItem> expressions;
    Stack<EItem> c;

    std::istringstream inexp(exp);
    int sum=0;
    while(inexp.peek()!=EOF){
        char ch=inexp.get();
        if(ch>='0' && ch<='9'){
            sum=sum*10+(int)ch-48;
        }
        else{
            EItem e(sum);
            expressions.push(e);
            for(int i=0;i<4;i++){
                EItem* ec=charItem[i].find(ch);
                if(ec!=NULL){
                    if(c.empty()){
                        c.push(*ec);
                        break;
                    }
                    int size=c.size();
                    for(int j=0;j<size;j++){

                        if(ec->priority>c.top().priority){
                            c.push(*ec);
                            break;
                        }
                        else{
                            EItem temp=c.top();
                            expressions.push(temp);
                            c.pop();
                            if(c.empty()){
                                c.push(*ec);
                                break;
                            }
                        }
                    }
                    break;
                }
            }
            
            sum=0;
        }
    }
    EItem e(sum);
    expressions.push(e);
    while(!c.empty()){
        expressions.push(c.top());
        c.pop();
    
    }

    int q=0;
    EItem* result=new EItem[200];
    while(!expressions.empty()){        
        result[q]=expressions.top();
        expressions.pop();
        q++;
    }
    for(int i=q-1;i>=0;i--){
        if(result[i].priority==0){
            expressions.push(result[i]);
        }
        else{
            int b=expressions.top().num;
            expressions.pop();
            int a=expressions.top().num;
            expressions.pop();
            switch((char)result[i].num){
                case '+':
                    expressions.push(a+b);
                    break;
                case '-':
                    expressions.push(a-b);
                    break;
                case '*':
                    expressions.push((int)(a*b));
                    break;
                case '/':
                    expressions.push((int)(a/b));
                    break;

            }
        }
    }
    return expressions.top().num;
}
int main(){
    charItem[0].num='+';
    charItem[0].priority=20;
    charItem[1].num='-';
    charItem[1].priority=20;        
    charItem[2].num='*';
    charItem[2].priority=30;
    charItem[3].num='/';
    charItem[3].priority=30;
    std::string exp;
    std::cin>>exp;
    std::cout<<calc(exp)<<std::endl;
    return 0;
}

给你个思路，就是使用栈去完成，当遇到‘(’ '/' ‘*’就进行压栈，遇到‘+’或‘-’就就先进行计算，然后再压入栈中，最后取栈里所有的值进行相加，就是你最后的值。
我是c++写的

int calculate(string s) {
        stack<int> Stack;
        int symbol='+';
        int length=s.size();
        for(int i=0;i<s.size();++i)
        {
            char ch=s[i];
            if(ch==' ')
                continue;
            if(ch>='0'&&ch<='9')
            {
                int num=0;
                while(i<length&&(ch=s[i])>='0'&&ch<='9')
                {
                    num=num*10-'0'+ch;
                    i++;
                }
                i--;
                if(symbol=='+')
                {
                    Stack.push(num);
                }
                else if(symbol=='-')
                {
                    Stack.push(-num);
                }
                else if(symbol=='*')
                {
                    int temp=Stack.top()*num;
                    Stack.pop();
                    Stack.push(temp);
                }
                else if(symbol=='/')
                {
                    int temp=Stack.top()/num;
                    Stack.pop();
                    Stack.push(temp);
                }
            }
            else
            {
                symbol=ch;
            }
        }
        int res=0;
        while(!Stack.empty())
        {
            res+=Stack.top();
            Stack.pop();
        }
        return res;
    }

这个题涉及到中缀表达式和后缀表达式，并且代码层面要使用堆栈来处理。如果没有这方面的知识建议先学习

1.定义两个栈数据结构，一个用于存储数值，一个存储运算符
2.解析表达式，遇到数值就压栈，遇到运算符就和运算符栈的栈顶运算符进行比较，如果比栈顶运算符优先级高就压栈，优先级等于或低于栈顶运算符，就取出该栈顶运算符，再从数值栈中取出两个数值进行计算，将计算结果压栈到数值栈中
3.计算完后数值栈中只有一个数据且运算符栈为空，该数据就为表达式的计算结果，否则说明表达式不正确存在语法错误。
4.计算过程中注意括号的特殊处理，还有栈中最后一个运算符的处理，注意以上几点应该就能解决楼主问题

采用栈和二叉树就可以实现算数表达式求值