表达式树

于 2019-10-12 03:52:33 发布
阅读量170 收藏
点赞数 1
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39942341/article/details/102513374
版权

目录

输出中缀表达式

获得表达式树的值

中缀表达式生成表达式树

后缀表达式生成表达式树

前缀表达式生成表达式树

获得后缀表达式

获得前缀表达式

 

#pragma once
#include "TreeNode.h"
#include<stack>
class ExpressionTree {
private:
    TreeNode* root;
    static int level(const char&);
    static int cmp(const char&, const char&);
    static bool is_operator(const char&);
    static void destroy(TreeNode**);
    bool should_print_parenthesis(TreeNode*, bool)const;
    void get_expression(TreeNode*, string&)const;
    double getValue(TreeNode*)const;
public:
    ExpressionTree() :root(nullptr) {};
    void destroy();
    ~ExpressionTree();
    void build_by_infix_expression(const string&);
    void build_by_rpn(const string&);
    void build_by_pn(const string&);
    string get_expression()const;
    string get_rpn()const;
    string get_pn()const;
    double getValue()const;
};

 辅助函数

/**
 * 获得操作符级别
 * @param op 操作符
 * @return 操作符级别
 */
int ExpressionTree::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 ExpressionTree::cmp(const char &left_operator, const char &right_operator) {
    if (left_operator == '(' && right_operator == ')') {
        return 0;
    }
    else if (right_operator == '(') {
        return 1;
    }
    int op1_level = level(left_operator);
    int op2_level = level(right_operator);
    if (op1_level < op2_level) {
        return 1;
    }
    return -1;
}
/**
 * 是否是操作符
 * @param op 字符
 * @return 是否是操作符
 */
bool ExpressionTree::is_operator(const char &op) {
    return op == '+' || op == '-' || op == '*' || op == '/' || op == '(' || op == ')';
}
/**
 * 销毁二叉树
 * @param rt 当前节点的地址
 */
void ExpressionTree::destroy(TreeNode **rt) {
    if ((*rt)->left != nullptr) {
        destroy(&((*rt)->left));
    }
    if ((*rt)->right != nullptr) {
        destroy(&((*rt)->right));
    }
    delete (*rt);
    *rt = nullptr;
}

输出中缀表达式

主要是中序遍历

关于括号

1、如果根节点是+号，那么无论左子树以及右子树是什么操作符，它们都是不需要加括号的，因为根节点+号是最小优先级的

2、如果根节点是-号，那么只有右子树是+号或者-号时，右子树才需要加括号（减号不满足结合律）

3、如果根节点是*号，那么只有左子树或右子树是+号或者-号时，它们才需要加括号

4、如果根节点是/号，那么如果左子树或右子树是+号或者-号时，它们需要加括号，其次，如果右子树是*号或者/号时，右子树也需要加括号（除号不满足结合律）

/**
 * 在输出中缀表达式时是否应该添加括号
 * @param rt 根
 * @param isLeft 左子树还是右子树
 * @return 是否应该添加括号
 */
bool ExpressionTree::should_print_parenthesis(TreeNode *rt, bool isLeft) const {
    if (rt == nullptr) {
        return false;
    }
    TreeNode* left = rt->left;
    TreeNode* right = rt->right;
    //叶子节点
    if (left == nullptr || right == nullptr) {
        return false;
    }
    string root_data = rt->data;
    string left_data = left->data;
    string right_data = right->data;
    //左子树
    if (isLeft) {
        //根是*,/时，如果左子树是+或者-，则他们优先级更高，应该先算，所以要加括号
        if (root_data == "*" || root_data == "/") {
            if (left_data == "+" || left_data == "-") {
                return true;
            }
        }
    }
    else {
        //根是-，*,/时，如果右子树是+或者-，则他们优先级更高，应该先算，所以要加括号
        if (root_data == "-" || root_data == "*" || root_data == "/") {
            if (right_data == "+" || right_data == "-") {
                return true;
            }//根是/时，如果右子树是*或者/,由于不满足结合律，所以要加括号
            else if (root_data == "/" && (right_data == "*" || right_data == "/")) {
                return true;
            }
        }
    }
    return false;
}
/**
 * 获得中缀表达式
 * @param rt 根
 * @param result 中缀表达式
 */
void ExpressionTree::get_expression(TreeNode *rt, string &result) const {
    if (rt == nullptr) {
        return;
    }
    //中序遍历

    if (rt->left != nullptr) {
        if (should_print_parenthesis(rt, true)) {
            result += "(";
            get_expression(rt->left, result);
            result += ")";
        }
        else {
            get_expression(rt->left, result);
        }
    }
    result += rt->data;
    if (rt->right != nullptr) {
        if (should_print_parenthesis(rt, false)) {
            result += "(";
            get_expression(rt->right, result);
            result += ")";
        }
        else {
            get_expression(rt->right, result);
        }
    }
}

获得表达式树的值

/**
 * 求表达式树的值
 * @param rt 根
 * @return 结果
 */
double ExpressionTree::getValue(TreeNode *rt) const {
    if (rt == nullptr) {
        return 0;
    }
    double left = getValue(rt->left);
    double right = getValue(rt->right);
    string op = rt->data;
    if (op == "+") {
        return left + right;
    }
    else if (op == "-") {
        return left - right;
    }
    else if (op == "*") {
        return left * right;
    }
    else if (op == "/") {
        return left / right;
    }
    return stod(rt->data);
}
/**
 * 求表达式树的值
 * @return 结果
 */
double ExpressionTree::getValue() const {
    return getValue(this->root);
}

中缀表达式生成表达式树

基本和中缀表达式求值一样

/**
 * 中缀表达式生成表达式树
 * @param expression 中缀表达式
 */
void ExpressionTree::build_by_infix_expression(const string &expression) {
    stack<TreeNode*> tree_stack;
    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 {
                    TreeNode* right = tree_stack.top();
                    tree_stack.pop();
                    TreeNode* left = tree_stack.top();
                    tree_stack.pop();
                    tree_stack.push(new TreeNode(left, right, 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;
            //操作数
            while ((j < expression.size() && ('0' <= expression[j] && expression[j] <= '9')) || expression[j] == '.') {
                ++j;
            }
            string temp = expression.substr(i, j - i);
            if (isNegative) {
                temp.insert(0,"-");
                isNegative = false;
            }
            tree_stack.push(new TreeNode(temp));
            i = j;
        }
    }
    char op = operators.top();
    //处理剩下的操作符
    while (op != '#') {
        TreeNode* right = tree_stack.top();
        tree_stack.pop();
        TreeNode* left = tree_stack.top();
        tree_stack.pop();
        tree_stack.push(new TreeNode(left, right, op));
        operators.pop();
        op = operators.top();
    }
    destroy();
    this->root = tree_stack.top();
}

后缀表达式生成表达式树

基本和后缀表达式求值一样

/**
 * 后缀表达式生成表达式树
 * @param expression 后缀表达式
 */
void ExpressionTree::build_by_rpn(const string &expression) {
//操作数
    stack<TreeNode*> tree_stack;
    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;
            }
            tree_stack.push(new TreeNode(expression.substr(i, j - i)));
            i = j;
        }
        else if (is_operator(expression[i])) {
            TreeNode* right = tree_stack.top();
            tree_stack.pop();
            TreeNode* left = tree_stack.top();
            tree_stack.pop();

            tree_stack.push(new TreeNode(left, right, expression[i]));
            ++i;
        }

    }
    destroy();
    this->root = tree_stack.top();
}

前缀表达式生成表达式树

基本和前缀表达式求值一样

/**
 * 前缀表达式生成表达式树
 * @param expression 前缀表达式
 */
void ExpressionTree::build_by_pn(const string &expression) {
    stack<TreeNode*> tree_stack;
    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;
            }
            tree_stack.push(new TreeNode(expression.substr(j + 1, i - j)));
            i = j;
        }
        else if (is_operator(expression[i])) {
            TreeNode* left = tree_stack.top();
            tree_stack.pop();
            TreeNode* right = tree_stack.top();
            tree_stack.pop();

            tree_stack.push(new TreeNode(left, right, expression[i]));
            --i;
        }
    }
    destroy();
    this->root = tree_stack.top();
}

获得后缀表达式

后序遍历

/**
 * 获得后缀表达式
 * @return 后缀表达式
 */
string ExpressionTree::get_rpn() const {
    string result;
    bool first = true;
    stack<TreeNode*> s;
    TreeNode* p = this->root, * pre = nullptr;
    while (p != nullptr || !s.empty()) {
        //压入当前节点
        while (p != nullptr) {
            s.push(p);
            p = p->left;
        }
        p = s.top();
        //如果没有右子树或者右子树已经访问过了，那么就可以访问根节点
        if (p->right == nullptr || p->right == pre) {
            if (!first) {
                result += " ";
            }
            first = false;
            result += p->data;
            pre = p;
            s.pop();
            p = nullptr;
        }
        else {
            //访问右子树
            p = p->right;
        }
    }
    return result;
}

获得前缀表达式

前序遍历

/**
 * 获得前缀表达式
 * @return 前缀表达式
 */
string ExpressionTree::get_pn() const {
    stack<TreeNode*> s;
    TreeNode* p = this->root;
    string result;
    bool first = true;
    while (p != nullptr || !s.empty()) {
        //一直向左子树访问
        while (p) {
            if (!first) {
                result += " ";
            }
            result += p->data;
            first = false;

            if (p->right != nullptr) {
                //存储右子树
                s.push(p->right);
            }
            p = p->left;
        }
        if (!s.empty()) {
            //右子树
            p = s.top();
            s.pop();
        }
    }
    return result;
}

参考资料：

https://juejin.im/post/5c3a2ab06fb9a049dd8084be

Nightmare004
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
用表达式树输出中缀表达式
05-21
给定一个表达式，输出其中缀表达式，利用了栈和二叉树，是理解数据结构很好的资料
表达式树Expression tree
09-27
C++实现的表达式树。测试的组合有 3 4 + 2 * 2 3 4 * + x x - a b + * x 1 * x 3 + 2 * 3 4 5 * + 3 4 5 ^ + 3 4 5 ^ % 31 x + 42 5 ^ % xcc xc - aa bb + * x 1 % x ^ 10 + 可将上面字符复制到测试文件中，文件名写死在了程序中 可实现简单的优化.
[翻译]表达式树基础
weixin_30740295的博客
03-05 119
原文来自Charlie Calvert的Expression Tree Basics表达式树基础 刚接触LINQ的人往往觉得表达式树很不容易理解。通过这篇文章我希望大家看到它其实并不像想象中那么难。您只要有普通的LINQ知识便可以轻松理解本文。 表达式树提供一个将可执行代码转换成数据的方法。如果你要在执行代码之前修改或转换此代码，那么它是非常有价值的。尤其是当你要将C#代码----如LIN...
C# - LINQ 表达式树
weixin_33785972的博客
10-06 618
表达式树（Expression Tree） 表达式树是不可执行的代码，它只是用于表示一种树状的数据结构，树上的每一个节点都表示为某种表达式类型，大概有25种表达式类型，它们都派生自Expression类。创建表达式树具体有两个优势： 1.对表达式树的代码进行编辑修改，使表达式树中的代码变成动态代码，根据不同的数据库修改树上的代码逻辑从而达到动态切换数据库查询语句的目的，用表达式树可以动态构建针...
二叉表达式树
热门推荐
zy010101博客
10-13 1万+
表达式树：表达式树的叶节点是操作数，其他节点是操作符。假设所有的运算符都是双目运算符，那么刚好形成一颗二叉树。我们可以通过递归计算左子树和右子树的值，从而得到整个表达式树的值。 这就是一颗表达式树，在这棵树中，只有叶节点是操作数，其他节点都是操作符。 我们先来遍历一下这棵树。前序遍历这棵树将会得到这样一个表达式：++a*bc*de;(这样的表达式，我们称之为前缀表达式，操作符位于操作数之前。...
表达式树的应用
10-20
动态创建表达式树、执行表达式树及表达式树的调试，使读者能熟练认识表达式树在动态查询上带来的便利。
四则混合运算表达式树处理
11-24
（2） 初始化表达式树； （3） 生成表达式树； （4） 输出表达式树的各种遍历的结果； （5） 打印表达式树； （6） 删除表达式树； （7） 设计相应的“菜单”，通过键盘输入选择，完成实验要求的测试。 [选作内容] ...
C# 表达式树Expression Trees的知识梳理
08-31
本篇文章主要介绍了表达式树 Expression Trees的基础知识：Lambda 表达式创建表达式树；API 创建表达式树；编译表达式树；执行表达式树；修改表达式树等等，具有一定的参考价值，下面跟着小编一起来看下吧
Expression表达式树动态查询.zip
12-11
C# 表达式树动态查询，可通过输入任意参数进行查询，详情请看博客使用介绍 。
快速计算表达式树
05-14 198
NET 3.5中新增的表达式树（Expression Tree）特性，第一次在.NET平台中引入了“逻辑即数据”的概念。也就是说，我们可以在代码里使用高级语言的形式编写一段逻辑，但是这段逻辑最终会被保存为数据。正因为如此，我们可以使用各种不同的方法对它进行处理。例如，您可以将其转化为一个SQL查询，或者外部服务调用等等，这便是LINQ to Everything在技术实现上的重要基石之一...
c# 委托 表达式树
最新发布
07-27
C#中的委托是一种类型，它可以持有对一个或多个方法的引用，并允许通过调用委托来间接调用这些方法。委托在表达式树中也有应用。 表达式树是一种数据结构，它表示代码中的表达式。它们可以动态地创建和修改，并且可以在运行时进行分析和执行。表达式树通常用于表示查询和动态生成代码。 在C#中，表达式树经常与LINQ（Language Integrated Query）一起使用，用于在运行时构建查询，例如数据库查询。通过使用表达式树，我们可以在编译时构建查询表达式，并在运行时将其解析为具体的查询。 使用委托和表达式树，我们可以创建动态的委托实例，并将其用作回调函数或事件处理程序。这使得我们能够在运行时动态地决定要调用的方法。 如果你有更具体的问题或示例代码，我可以为你提供更详细的解答。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Nightmare004

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值