精华内容
下载资源
问答
  • 数据结构 表达式求值数据结构 表达式求值数据结构 表达式求值
  • 表达式求值

    2019-03-20 22:10:10
    1. 中缀表达式A+B*(C-D)-E/F 转换为 后缀表达式 ABCD-*+EF/- 2.对于后缀表达式 扫描表达式每一项,if 是操作数 压入站 ... if 是操作符 连续从中退出两个数 并将计算结果 压入栈中 3.最终 栈顶就是结果 ...

    1.  中缀表达式A+B*(C-D)-E/F    转换为   后缀表达式  ABCD-*+EF/-

    2.对于后缀表达式 

                扫描表达式每一项,if 是操作数 压入站

                                                if 是操作符 连续从栈中退出两个数 并将计算结果  压入栈中

    3.最终 栈顶就是结果


    展开全文
  • 支持负号,小数 负号只能出现在表达式开始和紧贴着括号 ...中缀表达式求值 中缀表达式转后缀表达式 计算后缀表达式 中缀表达式转前缀表达式 计算前缀表达式 声明 #pragma once #include&...

    支持负号,小数

    负号只能出现在表达式开始和紧贴着括号

    大部分的思路都是维护一个栈,让优先级单调递减

    表达式中,*,/>  +,-  >  (,)  >  #,同级的话左边的大于右边

    目录

    声明

    辅助函数

    中缀表达式求值

    中缀表达式转后缀表达式

    计算后缀表达式

    中缀表达式转前缀表达式 

    计算前缀表达式 


    声明

    #pragma once
    #include<string>
    #include<stack>
    using namespace std;
    class Expressions {
    private:
        static int level(const char&);
        static int cmp(const char&, const char&);
        static bool is_operator(const char&);
        static double calculate(const double& left_operand, const double& right_operand, const char& op);
    public:
        static double infix_expression(const string&);
        static string expression_to_rpn(const string&);
        static double evaluate_rpn(const string&);
        static string expression_to_pn(const string&);
        static double evaluate_pn(const string&);
    };

    辅助函数

    /**
     * 获得操作符级别
     * @param op 操作符
     * @return 操作符级别
     */
    int Expressions::level(const char &op) {
        if (op == '#') {
            return 0;
        }
        else if (op == '(' || op == ')') {
            return 1;
        }
        else if (op == '+' || op == '-') {
            return 2;
        }
        return 3;
    }
    /**
     * 右边的操作符与左边的操作符对比
     * @param left_operator 表达式左边的操作符
     * @param right_operator 表达式右边的操作符
     * @return 大于返回1,等于返回0,小于返回-1
     */
    int Expressions::cmp(const char &left_operator, const char &right_operator) {
        //括号同级
        if (left_operator == '(' && right_operator == ')') {
            return 0;
        }
        else if (right_operator == '(') {
            //右边的括号一定是要先算的
            return 1;
        }
        if (level(left_operator) < level(right_operator)) {
            return 1;
        }
        //相同的操作符左边的优先级更高
        return -1;
    }
    /**
     * 是否是操作符
     * @param op 字符
     * @return 是否是操作符
     */
    bool Expressions::is_operator(const char &op) {
        return op == '+' || op == '-' || op == '*' || op == '/' || op == '(' || op == ')';
    }
    /**
     * 计算
     * @param left_operand 左操作数
     * @param right_operand 右操作数
     * @param op 操作符
     * @return 计算结果
     */
    double Expressions::calculate(const double &left_operand, const double &right_operand, const char &op) {
        if (op == '+') {
            return left_operand + right_operand;
        }
        else if (op == '-') {
            return left_operand - right_operand;
        }
        else if (op == '*') {
            return left_operand * right_operand;
        }
        return left_operand / right_operand;
    }
    

    中缀表达式求值

    /**
     * 计算中缀表达式
     * @param expression 中缀表达式
     * @return 计算结果
     */
    double Expressions::infix_expression(const string &expression) {
        //操作数栈
        stack<double> operands;
        //符号栈
        stack<char> operators;
        //表达式开始
        operators.push('#');
        //是否是负数
        bool isNegative = false;
        //是否读到第一个
        bool first = true;
        //左边是否是左括号
        bool pre_left_parenthesis = false;
        size_t i = 0;
        while (i < expression.size()) {
            //去除多余空格
            while (i < expression.size() && expression[i] == ' ') {
                ++i;
            }
            //结束
            if (i == expression.size()) {
                break;
            }
            //表达式第一个是负号
            if (expression[i] == '-' && first) {
                first = false;
                isNegative = true;
                ++i;
                continue;
            }
            first = false;
            char right_op = expression[i];
            if (is_operator(right_op)) {
                //-紧贴着左括号的话是负号
                if (right_op == '-' && pre_left_parenthesis) {
                    isNegative = true;
                    pre_left_parenthesis = false;
                    ++i;
                    continue;
                }
                pre_left_parenthesis = false;
                char left_op = operators.top();
                int cmp_result = cmp(left_op, right_op);
                //栈顶的操作符大于等于当前的操作符
                while (cmp_result != 1) {
                    //左括号碰到了右括号
                    if (cmp_result == 0) {
                        operators.pop();
                        break;
                    }
                    else {
                        double right_num = operands.top();
                        operands.pop();
                        double left_num = operands.top();
                        operands.pop();
                        operands.push(calculate(left_num, right_num, left_op));
    
                        operators.pop();
                        left_op = operators.top();
                        cmp_result = cmp(left_op, right_op);
                    }
                }
                if (right_op != ')') {
                    operators.push(right_op);
                    if (right_op == '(') {
                        pre_left_parenthesis = true;
                    }
    
                }
                ++i;
            }
            else {
                pre_left_parenthesis = false;
                size_t j = i + 1;
                while ((j < expression.size() && ('0' <= expression[j] && expression[j] <= '9')) || expression[j] == '.') {
                    ++j;
                }
                //操作数
                double temp = stod(expression.substr(i, j - i));
                //负数
                if (isNegative) {
                    temp = -temp;
                    isNegative = false;
                }
                operands.push(temp);
                i = j;
            }
        }
        char op = operators.top();
        //处理剩下的操作符
        while (op != '#') {
            double right_num = operands.top();
            operands.pop();
            double left_num = operands.top();
            operands.pop();
            operands.push(calculate(left_num, right_num, op));
            operators.pop();
            op = operators.top();
        }
        return operands.top();
    }

    中缀表达式转后缀表达式

    /**
     * 中缀表达式转后缀表达式(逆波兰式)
     * @param expression 中缀表达式
     * @return 后缀表达式
     */
    string Expressions::expression_to_rpn(const string &expression) {
        //后缀表达式
        string ans;
        //符号栈
        stack<char> operators;
        //是否是负数
        bool isNegative = false;
        //是否读到第一个
        bool first = true;
        //左边是否是左括号
        bool pre_left_parenthesis = false;
        size_t i = 0;
        operators.push('#');
        while (i < expression.size()) {
            //去掉多余的空格
            while (i < expression.size() && expression[i] == ' ') {
                ++i;
            }
            //结束
            if (i == expression.size()) {
                break;
            }
            //表达式第一个是负号
            if (expression[i] == '-' && first) {
                first = false;
                isNegative = true;
                ++i;
                continue;
            }
            first = false;
            char right_op = expression[i];
            if (is_operator(right_op)) {
                //-紧贴着左括号的话是负号
                if (right_op == '-' && pre_left_parenthesis) {
                    isNegative = true;
                    pre_left_parenthesis = false;
                    ++i;
                    continue;
                }
                pre_left_parenthesis = false;
                char left_op = operators.top();
                int cmp_result = cmp(left_op, right_op);
                //栈顶的操作符大于等于当前的操作符
                while (cmp_result != 1) {
                    operators.pop();
                    //左括号碰到了右括号
                    if (cmp_result == 0) {
                        break;
                    }
                    else {
                        ans.push_back(' ');
                        ans.push_back(left_op);
    
                        left_op = operators.top();
                        cmp_result = cmp(left_op, right_op);
                    }
                }
                if (right_op != ')') {
                    operators.push(right_op);
                    if (right_op == '(') {
                        pre_left_parenthesis = true;
                    }
    
                }
                ++i;
            }
            else {
                pre_left_parenthesis = false;
                size_t j = i + 1;
                while ((j < expression.size() && ('0' <= expression[j] && expression[j] <= '9')) || expression[j] == '.') {
                    ++j;
                }
    
                //操作数
                double temp = stod(expression.substr(i, j - i));
                //负数
                if (isNegative) {
                    temp = -temp;
                    isNegative = false;
                }
                ans += " ";
                ans += to_string(temp);
                i = j;
            }
        }
        char op = operators.top();
        //处理剩下的操作符
        while (op != '#') {
            ans.push_back(' ');
            ans.push_back(op);
            operators.pop();
            op = operators.top();
        }
        i = 0;
        //去掉前导空格
        while (i < ans.size() && ans[i] == ' ') {
            ++i;
        }
        return ans.substr(i);
    }

    计算后缀表达式

    /**
     * 计算后缀表达式(逆波兰式)
     * @param expression 后缀表达式
     * @return 计算结果
     */
    double Expressions::evaluate_rpn(const string &expression) {
        //操作数
        stack<double> operands;
        size_t i = 0;
        while (i < expression.size()) {
            //去除多余空格
            while (i < expression.size() && expression[i] == ' ') {
                ++i;
            }
            //结束
            if (i == expression.size()) {
                break;
            }
            //数字(包括负数)
            if ((expression[i] == '-' && i < expression.size() - 1 &&
                 '0' <= expression[i + 1] && expression[i + 1] <= '9') ||
                ('0' <= expression[i] && expression[i] <= '9')) {
                size_t j = i + 1;
                while ((j < expression.size() && ('0' <= expression[j] && expression[j] <= '9')) || expression[j] == '.') {
                    ++j;
                }
                double temp = stod(expression.substr(i, j - i));
                operands.push(temp);
                i = j;
            }
            else if (is_operator(expression[i])) {
                //计算
    
                double right_num = operands.top();
                operands.pop();
                double left_num = operands.top();
                operands.pop();
    
                operands.push(calculate(left_num, right_num, expression[i]));
                ++i;
            }
    
        }
        return operands.top();
    }

    中缀表达式转前缀表达式 

    /**
     * 中缀表达式转前缀表达式
     * @param expression 中缀表达式
     * @return 前缀表达式
     */
    string Expressions::expression_to_pn(const string &expression) {
        stack<string> result;
        stack<char> operators;
        operators.push('#');
        bool pre_minus = false;
        int i = static_cast<int>(expression.size() - 1);
        //左边的操作数与右边的操作符对比
        auto temp_cmp = [](const char& left_operator, const char& right_operator) {
            //左边的操作数的右括号要先算
            if (left_operator == ')'){
                return 1;
            }
            else if (left_operator == '(' && right_operator == ')'){
                return 0;
            }
            //相同的左边的优先级高
            if (level(left_operator) >= level(right_operator)){
                return 1;
            }
            return -1;
        };
        //从右边往左边扫描
        while (i >= 0) {
            //去掉多余的空格
            while (i >= 0 && expression[i] == ' ') {
                --i;
            }
            //结束
            if (i < 0) {
                break;
            }
            char left_op = expression[i];
            if (is_operator(left_op)) {
                if (left_op == '-') {
                    int j = i - 1;
                    while (j >= 0 && expression[j] == ' ') {
                        --j;
                    }
                    //表达式第一个是符号
                    if (j < 0) {
                        pre_minus = true;
                        break;
                    }
                }
                char right_op = operators.top();
                int cmp_result = temp_cmp(left_op, right_op);
                //栈顶的操作符大于等于当前的操作符
                while (cmp_result != 1) {
                    //左括号遇到右括号
                    if (cmp_result == 0) {
                        operators.pop();
                        break;
                    }
                    else {
                        result.push(string(1, right_op));
                        operators.pop();
                        right_op = operators.top();
                        cmp_result = temp_cmp(left_op, right_op);
                    }
                }
                if (left_op != '(') {
                    operators.push(left_op);
                    pre_minus = false;
                    if (left_op == '-') {
                        pre_minus = true;
                    }
                }
                else if (pre_minus) {
                    //左括号紧贴着的是符号,所以把栈顶的操作数变成负的
    
                    string t = result.top();
                    result.pop();
                    result.push("-" + t);
                    pre_minus = false;
                }
                --i;
            }
            else {
                pre_minus = false;
                int j = i - 1;
                while (j >= 0 && (('0' <= expression[j] && expression[j] <= '9') || expression[j] == '.')) {
                    --j;
                }
                result.push(expression.substr(j + 1, i - j));
                i = j;
            }
        }
        //表达式第一个是符号
        if (pre_minus) {
            operators.pop();
            string t = result.top();
            result.pop();
            result.push("-" + t);
        }
        char op = operators.top();
        //处理剩下的操作符
        while (op != '#') {
            result.push(string(1, op));
            operators.pop();
            op = operators.top();
        }
        string ans = result.top();
        result.pop();
        //逆序
        while (!result.empty()) {
            ans += " ";
            ans += result.top();
            result.pop();
        }
        return ans;
    }

    计算前缀表达式 

    /**
     * 计算前缀表达式(波兰式)
     * @param expression 前缀表达式
     * @return 计算结果
     */
    double Expressions::evaluate_pn(const string &expression) {
        //操作数栈
        stack<double> operands;
        int i = static_cast<int>(expression.size() - 1);
        //从右往左扫描
        while (i >= 0) {
            //去掉多余空格
            while (i >= 0 && expression[i] == ' ') {
                --i;
            }
            //结束
            if (i < 0) {
                break;
            }
            //操作数(包括负数)
            if ('0' <= expression[i] && expression[i] <= '9') {
                int j = i - 1;
                while (j >= 0 && (
                        ('0' <= expression[j] && expression[j] <= '9')
                        || expression[j] == '.'
                        || expression[j] == '-')) {
                    --j;
                }
                double temp = stod(expression.substr(j + 1, i - j));
                operands.push(temp);
                i = j;
            }
            else if (is_operator(expression[i])) {
                double left_num = operands.top();
                operands.pop();
                double right_num = operands.top();
                operands.pop();
    
                operands.push(calculate(left_num, right_num, expression[i]));
                --i;
            }
        }
        return operands.top();
    }
    

     

    展开全文
  • 表达式求值算法c/c++

    千次阅读 多人点赞 2018-03-22 23:22:48
    表达式求值,一般采用和队列的方式来求值,下面介绍表达式求值的两种算法。方法一、使用两个,一个为操作符OPTR(operator),一个是操作数OPND(operand) 算法过程: 当输入 3 * ( 4 - 1 * 2 ) + 6 / ( 1 + 1 ...
    表达式求值,一般采用栈和队列的方式来求值,下面介绍表达式求值的两种算法。

    方法一、使用两个栈,一个为操作符栈OPTR(operator),一个是操作数栈OPND(operand)
    算法过程:
    当输入 3 * ( 4 - 1 * 2 ) + 6 / ( 1 + 1 )时,先将输入的数据存储在一个字符数组中,按照字符的顺序一个一个的处理,比如

    ch = getchar()
    
    • 1
    • 2

    然后根据ch 的值判断。

    • ch 是数字,直接压入操作数栈OPND
    • ch'(',直接入栈OPTR;若 ch')',若OPTROPND 非空,弹出OPTR的栈顶操作符,弹出OPND栈顶的两个操作数,做运算,然后见个结果压入栈OPND,直到弹出的OPTR栈顶元素时')';
    • ch 是操作符(比如+, -, *, /),如果OPTR栈顶元素是 (,直接入栈OPTR,如果不是'('OPTR栈非空且栈顶元素操作符的优先级大于ch,那么弹出OPTR的栈顶操作符,并弹出OPND中栈顶的两个元素,做运算,将运算结果入栈OPND,此时,重复这一步操作;否则将ch入栈OPTR
    • ch为EOF,说明表达式已经输入完成,判断OPTR是否为空,若非空,一次弹出OPTR栈顶操作符,并与OPND栈顶两个元素做运算,将运算结果入栈OPND,最后表达式的结果即OPND的栈底元素。

    以表达式3 * ( 4 - 1 * 2 ) + 6 / ( 1 + 1 )为例,计算过程如下所示:

    OPTROPNDch备注
     33 
    *3* 
    *,(3( 
    *,(3,44 
    *,(,-3,4- 
    *,(,-3,4,11 
    *,(,-,*3,4,1* 
    *,(,-,*3,4,1,22 
    *,(,-3,4,2)OPND弹出2和1,OPTR弹出*,计算结果入栈OPND
    *,(3,2)OPND弹出2和4,OPTR弹出-,计算结果入栈OPND
    *3,2)OPTR栈顶弹出的是)
    +6+OPTR栈顶元素优先级大于ch,将OPND栈的3和2与OPTR的*运算,结果入栈OPND,ch入栈OPTR
    +6,66 
    +,/6,6/ 
    +,/,(6,6( 
    +,/,(6,6,11 
    +,/,(,+6,6,1+ 
    +,/,(,+6,6,1,11 
    +,/,(6,6,2)OPND的1和1,与OPTR的+运算,结果入栈OPND
    +,/6,6,2) 
    +6,3 表达式已经输入完成,OPTR非空,继续计算。OPND的2和6,OPTR的/运算
     9 计算结果
    #include <iostream>
    #include <algorithm>
    #include <cstring>
    #include <stack>
    #include <cmath>
    
    using namespace std;
    
    char s[1000];
    int  g_pos;  // 字符数组的下标
    
    /* 字符转数字 */
    double Translation(int & pos)
    {
        double integer = 0.0;    // 整数部分
        double remainder = 0.0;  // 余数部分
    
        while (s[pos] >= '0' && s[pos] <= '9')
        {
            integer *= 10;
            integer += (s[pos] - '0');
            pos++;
        }
    
        if (s[pos] == '.')
        {
            pos++;
            int c = 1;
            while (s[pos] >= '0' && s[pos] <= '9')
            {
                double t = s[pos] - '0';
                t *= pow(0.1, c);
                c++;
                remainder += t;
                pos++;
            }
        }
    
        return integer + remainder;
    }
    
    /* 返回运算符级别 */
    int GetLevel(char ch)
    {
        switch (ch)
        {
        case '+':
        case '-':
            return 1;
        case '*':
        case '/':
            return 2;
        case '(':
            return 0;
        case '#':
            return -1;
        };
    }
    
    /* 对两个数进行运算 */
    double Operate(double a1, char op, double a2)
    {
        switch (op)
        {
        case '+':
            return a1 + a2;
        case '-':
            return a1 - a2;
        case '*':
            return a1 * a2;
        case '/':
            return a1 / a2;
        };
    }
    
    /* 利用两个栈进行模拟计算 */
    double Compute()
    {
        stack<char> optr;    // 操作符栈
        stack<double> opnd;  // 操作数栈
    
        optr.push('#');      //置于符栈顶
        int len = strlen(s);
        bool is_minus = true;  // 判断'-'是减号还是负号, true表示负号
    
        for (g_pos = 0; g_pos < len;)
        {
            //1. 负号
            if (s[g_pos] == '-' && is_minus)  // 是负号
            {
                opnd.push(0);
                optr.push('-');
                g_pos++;
            }
            //2. 是右括号 )
            else if (s[g_pos] == ')')
            {
                is_minus = false;
                g_pos++;
    
                while (optr.top() != '(')
                {
                    double a2 = opnd.top();
                    opnd.pop();
                    double a1 = opnd.top();
                    opnd.pop();
                    char op = optr.top();
                    optr.pop();
    
                    double result = Operate(a1, op, a2);
                    opnd.push(result);
                }
                optr.pop();  // 删除'('
            }
            //3. 数字
            else if (s[g_pos] >= '0' && s[g_pos] <= '9')
            {
                is_minus = false;
                opnd.push(Translation(g_pos));
            }
            //4. ( 左括号
            else if (s[g_pos] == '(')
            {
                is_minus = true;
                optr.push(s[g_pos]);
                g_pos++;
            }
            //5. + - * / 四种
            else
            {
                while (GetLevel(s[g_pos]) <= GetLevel(optr.top()))    //当前优先级小于栈尾优先级
                {
                    double a2 = opnd.top();
                    opnd.pop();
                    double a1 = opnd.top();
                    opnd.pop();
                    char op = optr.top();
                    optr.pop();
    
                    double result = Operate(a1, op, a2);
                    opnd.push(result);
                }
    
                optr.push(s[g_pos]);
                g_pos++;
            }
        }
    
        while (optr.top() != '#')
        {
            double a2 = opnd.top();
            opnd.pop();
            double a1 = opnd.top();
            opnd.pop();
            char op = optr.top();
            optr.pop();
    
            double result = Operate(a1, op, a2);
            opnd.push(result);
        }
    
        return opnd.top();
    }
    
    int main()
    {
        while (cin >> s)
            cout << "结果为:" << Compute() << endl << endl;
    
        return 0;
    }
    
    


    展开全文
  • 栈表达式求值(C++)

    2020-10-28 17:46:59
    用到的一些库函数宏定义等: #define CRT_SECURE_NO_WARNINGS #include <iostream> #define MaxSize 100 ...由于是用进行表达式的求解,我自己写的的一下必须的操作: typedef struct { char a[100]; int

    用到的一些库函数宏定义等:

    #define CRT_SECURE_NO_WARNINGS
    #include <iostream>
    #define MaxSize 100
    #define OK 1
    #define ERROR 0
    using namespace std;
    typedef char ElemType;
    typedef int Status;

    由于是用栈进行表达式的求解,我自己写的栈的一下必须的操作:

    typedef struct {
        char a[100];
        int top;
        int base;
    }Stack;
    Stack OPTR;
    Stack OPND;
    void InitS(Stack& S) {
        S.top = 0;
        S.base = 0;
    }
    char GetTop(Stack S) {
        char e;
        e = S.a[S.top - 1];
        return e;
    }
    void Push(Stack& S, char x) {
        S.a[S.top++] = x;
    }
    void Pop(Stack& S, char& x) {
        x = S.a[--S.top];
    }

    接下来的函数时为了表达式求值的一下判定:

    int IN(char a) {
        if (a >= '0' && a <= '9') return 1;
        else return 0;
    }//判断字符a是不是所要输入的数字;
    int Kol(char a) {
        if (a == '+') return 0;
        if (a == '-') return 1;
        if (a == '*') return 2;
        if (a == '/') return 3;
        if (a == '(') return 4;
        if (a == ')') return 5;
        if (a == '#') return 6;
    }//来进行符号的编号;
    char Precede(char a, char b) {
        char as[][7] = {
            {'>', '>', '<', '<', '<', '>', '>',},
            {'>', '>', '<', '<', '<', '>', '>',},
            {'>', '>', '>', '>', '<', '>', '>',},
            {'>', '>', '>', '>', '<', '>', '>',},
            {'<', '<', '<', '<', '<', '=', '0',},
            {'>', '>', '>', '>', '0', '>', '>',},
            {'<', '<', '<', '<', '<', '=', '0',},
        };
        int id1, id2;
        id1 = Kol(a);
        id2 = Kol(b);
        return as[id1][id2];
    }//进行两个符号的比较,来判断是否应该入栈或者数出栈或者时计算;
    int Oper(int a, char theta, int b) {
        if (theta == '+') return a + b;
        if (theta == '-') return a - b;
        if (theta == '*') return a * b;
        if (theta == '/') return a / b;
    }//来进行+ - * /的四则运算,以便于将运算的结果再入栈到数字栈中;

    最重要的一部分:

    //该算法要求对数的大小不可以超过9;
    char E_E() {
        char theta, a, b, x;
        InitS(OPND);//来储存数字的栈;
        InitS(OPTR);//来储存符号的栈;
        Push(OPTR, '#');//首先先向储存符号的栈中入栈一个‘#’;
        char ch;
        cin >> ch;
        while (ch != '#' || GetTop(OPTR) != '#') {//当符号栈顶的元素为‘#’而且输入的祖父为‘#’时结束;
            if (IN(ch)) { Push(OPND, ch - '0'); cin >> ch; }//如果输入的是数字就入数字栈;
            else {//否则进行下列一系列的判断;
                switch (Precede(GetTop(OPTR), ch)) {//通过符号栈栈顶元素和输入的字符的比较来决定进行什么操作;
                case '<': Push(OPTR, ch); cin >> ch; break;//当符号为‘<’时,入符号栈;并继续输入字符;
                case '>': Pop(OPTR, theta); Pop(OPND, b); Pop(OPND, a); Push(OPND, Oper(a, theta, b)); break;//当符号为‘>’时,出字符栈,并出两次数字栈,进行计算将计算结果进入数字栈;此时并不进行下一个字符的输入;继续判断;
                case '=': Pop(OPTR, x); cin >> ch; break;//当符号为‘=’时,就是左括号和右括号相遇,出符号栈即可;并进行字符的输入;
                }
            }
        }
        return GetTop(OPND);//运算结果就是最后数字栈中的唯一的元素,也就是数字栈的栈顶元素;
    }

    可怜而又弱小的主函数:

    int main() {
        int ans = E_E();
        printf("%d", ans);//要强制输出int型的;用cout是字符型的;
        return 0;
    }

    在这里插入图片描述

    展开全文
  • 表达式求值的经典问题, 首先设置一个开始和结束符号#,他们的优先级是最低的,然后开两个,运算符和运算数,如果当前要放的运算符优先级高的话,就放进去,然后继续模拟,如果当前要放的运算符优先级低的...
  • 数据结构利用的两种方法计算表达式求值 c语言版 原本代码 可以直接下载运行 纯原创作 可满足数据结构作业或者实验报告 也可以熟悉的应用···
  • C/C++计算器(利用栈表达式求值,支持函数运算)

    千次阅读 热门讨论 2017-12-13 16:22:06
    表达式求值是程序设计语言编译中的一个基本问题。它的实现就是对“”的典型应用。其实现思想和数据结构书上基本一致,不同的增加的函数计算,并可以扩充,利用两个:一个操作数和一个运算符。计算器C/C++...
  • 实现加减乘除 的云孙的离开几分无奈ujhekwdfe哦ijddklh
  • 栈表达式求值程序

    千次阅读 2007-03-22 15:54:00
     //若不空,则删除S的栈顶元素,用e返回其,并返回OK;否则返回ERROR  if(S.top == S.base) return ERROR;  e = * --S.top;  return OK; } char In(char c,char OP[]) {  if(c>=35 && c)  return 1;  ...
  • 数据结构实现表达式求值数据结构实现表达式求值数据结构实现表达式求值数据结构实现表达式求值
  • c语言 表达式求值 代码 vs2013 课程设计 答辩 自写可用,
  • 实现表达式求值

    2011-12-27 22:30:35
    实现表达式求值
  • 这几天一直在写表达式求值
  • 给定一个表达式,其中运算符仅包含 +,-,*,/(加 减 乘 整除),可能包含括号,请你表达式的最终。 注意: 数据保证给定的表达式合法。 题目保证符号 - 只作为减号出现,不会作为负号出现,例如,-1+2,(2+2)*...
  • 用静态实现表达式求值.用静态实现表达式求值.
  • C++用实现表达式求值,经过验收的,可以运行,没有问题
  • C语言数据结构用实现表达式求值,全部工程代码。实现visual2010下运行
  • 表达式求值

    2020-02-06 18:51:50
    表达式求值 版权声明:本文为CSDN博主「lijgcn」的原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接及本声明。 原文链接:https://blog.csdn.net/lijgcn/article/details/70166432 #include <...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,064
精华内容 1,625
关键字:

栈表达式求值