C++中缀表达式建立表达式树

最新推荐文章于 2023-10-20 09:24:38 发布
最新推荐文章于 2023-10-20 09:24:38 发布
阅读量542 收藏
点赞数 1
文章标签： c++ 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xdpcxq/article/details/128849108
版权

//算符优先级
typedef struct _Priority
{
    char op;
    int isp;
    int icp;
}Priority;

const int symbols = 8;
static Priority pri_table[symbols] =
{
    {'#', 0, 0},
    {'+', 3, 2},
    {'-', 3, 2},
    {'*', 5, 4},
    {'/', 5, 4},
    {'^', 6, 7},
    {'(', 1, 8},
    {')', 8, 1}
};
inline bool isDigit(char ch)
{
    return ch >= '0' && ch <= '9';
}
inline bool opNumber(char ch)
{
    return (( ch >= '0' && ch <= '9' || ch == '.')  ||
            ( ch == '@' || ch == '#' || ch == '$' || ch == '%' || ch == '&' ) || (ch == 'R' || ch == 'P'));
}
inline bool isLetterUnderline(char ch)
{
    return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || ch == '_';
}
inline bool FloatEqualZero(float f)
{
    return (f >= -FLT_EPSILON && f <= FLT_EPSILON);
}
bool isDigitStr(const char * str , float &val)
{
    bool bRet = false;
    val = 0.00f;
    if (str == NULL)
    {
        return bRet;
    }
    size_t len = strnlen(str,MAX_EXP);
    if (len >= MAX_EXP)
    {
        return bRet;
    }
    float hasDot = false;
    float w = 1;
    for (int i=0; i<(int)len; ++i)
    {
        if (isDigit(str[i]) || str[i] == '.')
        {
            if(str[i] == '.')
            {
                if(hasDot)
                {
                    bRet =false;
                    break;
                }
                hasDot = true;
            }
            else
            {
                if(hasDot)
                {
                    w *= 0.1f;
                    val += (str[i] - '0') * w;
                }
                else
                {
                    val = val * 10 + str[i] - '0';
                }
            }
        }
        else
        {
            bRet = false;
            break;
        }
    }
    return bRet;
}
typedef enum _NodeType
{
    NODE_TYPE_OP,
    NODE_TYPE_NUM,
    NODE_TYPE_VAR,
    NODE_TYPE_EXPAND_VAR,
    NODE_TYPE_PARAM,
    NODE_TYPE_RANDOM
}NodeType;


//中缀表达式建树
bool ExpTree::CreateExpTree(const char * str)
{
    bool b = scanNode(str);
    if (!b)
    {
        return false;
    }
    std::stack<ExpNode*> node_stack;
    std::stack<ExpNode*> op_stack;
    ExpNode temp_node;
    temp_node.type = NODE_TYPE_OP;
    temp_node.op = '#';
    op_stack.push(&temp_node);
    for (int i = 0; i < count; i++)
    {
        if (nodes[i].type == NODE_TYPE_NUM || nodes[i].type == NODE_TYPE_VAR ||
            nodes[i].type == NODE_TYPE_PARAM || nodes[i].type == NODE_TYPE_RANDOM)
        {
            nodes[i].left = NULL;
            nodes[i].right = NULL;
            node_stack.push(&nodes[i]);
        }
        else if (nodes[i].type == NODE_TYPE_OP)
        {
            switch (nodes[i].op)
            {
            case '(':
                {
                    op_stack.push(&nodes[i]);
                }
                break;
            case ')':
                {
                    while (op_stack.top()->op != '(')
                    {
                        ExpNode *op = op_stack.top();
                        op_stack.pop();
                        ExpNode *right = node_stack.top();
                        node_stack.pop();
                        ExpNode *left = node_stack.top();
                        node_stack.pop();
                        op->left = left;
                        op->right = right;
                        node_stack.push(op);
                    }
                    if (op_stack.empty())
                    {
                        return false;
                    }
                    op_stack.pop(); //弹出栈顶左括号
                }
                break;
            case '+':
            case '-':
            case '*':
            case '/':
            case '^':
                {
                    while (cmpSymbolPri(op_stack.top()->op, nodes[i].op) >= 0)
                    {
                        ExpNode *op = op_stack.top();
                        op_stack.pop();
                        ExpNode *right = node_stack.top();
                        node_stack.pop();
                        ExpNode *left = node_stack.top();
                        node_stack.pop();
                        op->left = left;
                        op->right = right;
                        node_stack.push(op);
                    }
                    op_stack.push(&nodes[i]);
                }
                break;
            default:
                return false;
                break;
            }
        }
        else
        {
            return false;
        }
    }
    while (op_stack.top()->op != '#')
    {
        ExpNode *op = op_stack.top();
        op_stack.pop();
        ExpNode *right = node_stack.top();
        node_stack.pop();
        ExpNode *left = node_stack.top();
        node_stack.pop();
        op->left = left;
        op->right = right;
        node_stack.push(op);
    }
    op_stack.pop();
    if(node_stack.size() != 1)
    {
        return false;
    }
    root = node_stack.top();
    node_stack.pop();
    return true;

}
float ExpTree::Value()
{
    return valNode(root);
}

//计算
float ExpTree::cacul(float a, char op, float b)
{
    float ret = 0.00f;
    switch (op)
    {
    case '+':
        ret = a + b;
        break;
    case '-':
        ret = a - b;
        break;
    case '*':
        ret = a * b;
        break;
    case '/':
        {
            if(!FloatEqualZero(b))
            {
                ret = a / b;
            }
        }
        break;
    case '^':
        ret = pow(a, b);
        break;
    default:
        break;
    }
    return ret;
}
//求值函数
float ExpTree::valNode(ExpNode* cur)
{
    float res = 0.0f;
    if (cur->type == NODE_TYPE_OP)
    {
        res = cacul(valNode(cur->left), cur->op, valNode(cur->right));

        //计算随机上下限
        if (cur->left->chValue[0] == 'R')
        {
            min_value = cacul(min_value,cur->op,valNode(cur->right));
            max_value = cacul(max_value,cur->op,valNode(cur->right));
        }
        else if (cur->right->chValue[0] == 'R')
        {
            min_value = (valNode(cur->left),cur->op,min_value);
            max_value = (valNode(cur->left),cur->op,max_value);
        }
    }
    else
    {
        if (cur->type == NODE_TYPE_NUM)
        {
            res = cur->fValue * cur->sign;
        }
        else if (cur->type == NODE_TYPE_VAR || cur->type == NODE_TYPE_EXPAND_VAR || cur->type == NODE_TYPE_PARAM || cur->type == NODE_TYPE_RANDOM)
        {
            res = GetParamValue(cur->chValue) * cur->sign;
        }
    }

    return res;
}
int ExpTree::cmpSymbolPri(const char &ispop, const char &icpop)
{
    int pri_isp = -1;
    int pri_icp = -1;
    for (int i=0,j=0; i< symbols;i++)
    {
        if (pri_table[i].op == ispop)
        {
            pri_isp = pri_table[i].isp;
            ++j;
            if (j == 2)
            {
                break;
            }
        }
        if(pri_table[i].op == icpop)
        {
            pri_icp = pri_table[i].icp;
            ++j;
            if (j == 2)
            {
                break;
            }
        }
    }
    return pri_isp - pri_icp;
}

bool ExpTree::scanNumber(const char * str, int len, float &val, int &bytes)
{
    if (len < 0)
        return false;
    val = 0.00f;
    bool hasDot = false;
    float w = 1;
    int i=0;
    for(;i<len; i++)
    {
        if (isDigit(str[i]) || str[i] == '.')
        {
            if(str[i] == '.')
            {
                if(hasDot)
                {
                    return false;;
                }
                hasDot = true;
            }
            else
            {
                if(hasDot)
                {
                    w *= 0.1f;
                    val += (str[i] - '0') * w;
                }
                else
                {
                    val = val * 10 + str[i] - '0';
                }
            }
        }
        else
        {
            break;
        }
    }
    bytes = i-1;
    return true;
}
bool ExpTree::scanSymbol(const char * str, int len, char * buf, int &bytes)
{

    
    //最少两个字符'@' '#' '$' '%' 与一个字母的组合
    if (len< 2)
    {
        return false;
    }
    int i=0;
    buf[i] = str[i];
    i++;
    //首字符必须是字母或者数字或下划线
    if (isLetterUnderline(str[i]))
    {
        
        buf[i] = str[i];
        i++;
         for (; i<len; i++)
        {
            //后序字符
            if(isLetterUnderline(str[i]) || isDigit(str[i]))
            {
                buf[i] = str[i];
            }
            else
            {
                break;
            }
        }
    }
    else
    {
        return false;
    }
    buf[i] = '\0';
    bytes = i-1;
    return true;
}
bool ExpTree::scanExpandSymbol(const char * str, int len, char * buf, int &bytes)
{
    //最少三个字符'&' 数字 与一个字母的组合
    if (len< 3)
    {
        return false;
    }
    int i=0;
    //'&'符号
    buf[i] = str[i];
    i++;
    //首字符必须是字母或者数字或下划线
    if (isLetterUnderline(str[i]))
    {
        
        buf[i] = str[i];
        i++;
         for (; i<len; i++)
        {
            //后序字符
            if(isLetterUnderline(str[i]) || isDigit(str[i]))
            {
                buf[i] = str[i];
            }
            else
            {
                break;
            }
        }
    }
    else
    {
        return false;
    }
    buf[i] = '\0';
    bytes = i-1;
    return true;
}
bool ExpTree::scanRandom(const char * str, int len, char * buf, int &bytes)
{
    
    //R[M,N] or R[M]
    if (len < 6)
    {
        return false;
    }
    int i=0;
    //R
    buf[i] = str[i];
    i++;
    //[
    if (str[i] != '[')
    {
        return false;
    }
    buf[i] = str[i];
    i++;
    bool find = false;
    for (; i<len; i++)
    {
        buf[i] = str[i];
        if(buf[i] == ']')
        {
            find = true;
            break;
        }
    }
    if (!find)
    {
        return false;
    }
    buf[i] = str[i];
    i++;
    buf[i] = '\0';
    bytes = i-1;
    return true;

}
bool ExpTree::scanParam(const char * str, int len, char * buf, int &bytes)
{
    if (len < 2)
    {
        return false;
    }
    int i=0;
    buf[i]=str[i];
    i++;
    buf[i]=str[i];
    i++;
    buf[i]='\0';
    bytes = i-1;
    return true;
}
float ExpTree::query_prop_value(char chr, const char* prop_name)
{
    PERSISTID obj = PERSISTID();
    float ret = 0.00f;
    if (chr == '@') //自己
    {
        IGameClient* pGameClient = (IGameClient*)CHelper::GetGameClient();
        obj = pGameClient->GetPlayer();
    }
    //else if (chr == '#')
    //{
    //    obj = m_skill;
    //}
    //else if (chr == '$')
    //{
    //    obj = m_target;
    //}
    //else if (chr == '%')
    //{
    //    obj = m_target_skill;
    //}

    if (obj != PERSISTID())
    {
        ret = QueryPropValue(obj,prop_name);
    }
    return ret;
}
float ExpTree::query_expand_prop_value(const char* prop_name, char from)
{
    float ret = 0.0f;
    //ret = QueryPropValueBySource(pGameObject, m_self, prop_name, (RefreshPropSourceType)from);
    ret = QueryPropValueBySource(prop_name,int(from));

    return ret;
}
float ExpTree::GetParamValue(const char *szFormula)
{
    float res = 0.0f;
    int len = static_cast<int>(strnlen(szFormula, MAX_NODE_EXP-1));
    if (len == 0 || len >= MAX_NODE_EXP-1)
    {
        return res;
    }
    if (isDigit(szFormula[0]) || szFormula[0] == '.')
    {
        bool hasDot = false;
        float w = 1;
        for(int i=0;i<len; i++)
        {
            if (isDigit(szFormula[i]) || szFormula[i] == '.')
            {
                if(szFormula[i] == '.')
                {
                    if(hasDot)
                    {
                        res = 0.00f;
                        break;
                    }
                    hasDot = true;
                }
                else
                {
                    if(hasDot)
                    {
                        w *= 0.1f;
                        res += (szFormula[i] - '0') * w;
                    }
                    else
                    {
                        res = res * 10 + szFormula[i] - '0';
                    }
                }
            }
            else
            {
                res = 0.00f;
                break;
            }
        }
    }
    else if(szFormula[0] == '@' || szFormula[0] == '#' || szFormula[0] == '$' || szFormula[0] == '%')
    {
        char var[MAX_NODE_EXP];
        int i = 0;
        //去掉头@ # $ %
        while(i<len-1)
        {
            var[i]=szFormula[i+1];
            i++;
        }
        var[i]=0;
        res = query_prop_value(szFormula[0],var);
    }
    else if (szFormula[0] == '&')
    {
        char var[MAX_NODE_EXP];
        //去掉 &
        int i=0;
        //获取参数
        while(i<len-1)
        {
            var[i]=szFormula[i+1];
            i++;
        }
        var[i]=0;
        res = query_expand_prop_value(var, 3);
    }
    //判断是否是属性相关的变量
    else if (szFormula[0] == 'P')
    {   
        int index = szFormula[1] - '1';

        if (index < MAX_PARAM)
        {
            res= param[index];
        }
    }

    //判断是否是随机数相关的变量，格式R[P1,P2]或R[P1]
    else if (szFormula[0] == 'R')
    {
        //查找是否有逗号
        const char *cfind = strchr(szFormula, ',');
        if (cfind == NULL)
        {
            //没有逗号，取一个变量的随机数
            char var[MAX_NODE_EXP];
            int i=0;
            while(i<len-3)
            {
                var[i]=szFormula[2+i];
                i++;
            }
            var[i]=0;
            float max = GetParamValue(var);
            res = (float)util_random_float(max);

            //保存随机范围
            min_value = 0.0f;
            max_value = max;
        }
        else
        {
            //有逗号，取两个变量间的随机数
            char var[MAX_NODE_EXP];
            int split = (int)(cfind - szFormula);
            int i=0;
            while(i<split-2)
            {
                var[i]=szFormula[2+i];
                i++;
            }
            var[i]=0;
            float min = GetParamValue(var);
            i=0;
            while(i<len-split-2)
            {
                var[i]=szFormula[split+1+i];
                i++;
            }
            var[i]=0;
            float max = GetParamValue(var);
            if (max < min)
            {
                //转化为合法的范围
                float temp = min;
                min = max;
                max = temp;
            }
            res = min + (float)util_random_float((float)(max - min));

            //保存随机范围
            min_value = min;
            max_value = max;
        }
    }
    return res;
}
bool ExpTree::scanNode(const char * str)
{
    int len = (int)strnlen(str,MAX_EXP-1);
    if (len == MAX_EXP-1 || len == 0)
    {
        return false;
    }
    int i, sign;
    //inNum标记当前是否可以输入操作数
    bool inNum;
    for(i = 0, sign = 1, inNum = true; i<len; i++)
    {
        if(opNumber(str[i]))
        {
            if(inNum)
            {
                int bytes = 0;
                bool b = false;
                if (isDigit(str[i]) || str[i] == '.')
                {
                    nodes[count].type = NODE_TYPE_NUM;
                    b = scanNumber(&str[i],len-i,nodes[count].fValue, bytes);
                }
                else if (str[i] == '@' || str[i] == '#' || str[i] == '$' || str[i] == '%')
                {
                    nodes[count].type = NODE_TYPE_VAR;
                    b = scanSymbol(&str[i],len-i, nodes[count].chValue, bytes);
                }
                else if (str[i] == '&')
                {
                    nodes[count].type = NODE_TYPE_EXPAND_VAR;
                    b = scanExpandSymbol(&str[i],len-i, nodes[count].chValue, bytes);
                }
                else if (str[i] == 'R')
                {
                    nodes[count].type = NODE_TYPE_RANDOM;
                    b = scanRandom(&str[i],len-i,nodes[count].chValue, bytes);
                }
                else if (str[i] == 'P')
                {
                    nodes[count].type = NODE_TYPE_PARAM;
                    b = scanParam(&str[i],len-i,nodes[count].chValue, bytes);
                }
                else
                {
                    return false;
                }
                if(!b)
                {
                    return false;
                }
                i += bytes;
                nodes[count].sign = sign;
                count ++;
                if (count > MAX_NODE)
                {
                    return false;
                }
                sign = 1;
                inNum = false;
            }
            else
            {
                return false;
            }
        }
        else
        {
            switch(str[i])
            {
            case '(':
            case ')':
                {
                    nodes[count].type = NODE_TYPE_OP;
                    nodes[count].op = str[i];
                    count ++;
                    if (count > MAX_NODE)
                    {
                        return false;
                    }
                }
                break;
            case '+':
            case '-':
            case '*':
            case '/':
            case '^':
                {
                    if(inNum)
                    {
                        if(str[i] != '+' && str[i] != '-') throw true;
                        while(str[i] == '+' || str[i] == '-')
                        {
                            if(str[i] == '-')
                                sign *= -1;
                            i++;
                        }
                        i--;
                    }
                    else
                    {
                        nodes[count].type = NODE_TYPE_OP;
                        nodes[count].op = str[i];
                        count ++;
                        if (count > MAX_NODE)
                        {
                            return false;
                        }
                        inNum = true;
                    }
                }
                break;
            default:
                return false;
                break;
            }
        }
    }
    return count > 0;
}

float ExpTree::calculate_param(const PERSISTID& skill,const char * szFormula, const float (&arg)[MAX_PARAM])
{
    if (szFormula == NULL)
    {
        return 0.00f;
    }
    size_t len = strnlen(szFormula,MAX_EXP-1);
    if (len == 0 || len == MAX_EXP-1)
    {
        return 0.00f;
    }
    memset(param,0,sizeof(param));
    memcpy(param,arg,sizeof(float) * MAX_PARAM);
    bool b = CreateExpTree(szFormula);
    if (!b)
    {
        return 0.00f;
    }

    m_skill = skill;
    min_value = 0.0f;
    max_value = 0.0f;

    return (float)Value();
}

void ExpTree::GetRandomLimits( float& min_value,float& max_value )
{
    min_value = this->min_value;
    max_value = this->max_value;
}

float QueryPropValue( const PERSISTID& obj, const char* prop_name )
{
    float ret = 0.0f;
    if (obj.IsNull() || strcmp(prop_name,"") == 0)
    {
        return ret;
    }

    IGameObject* pGameObject = (IGameObject*)CHelper::GetEntity(obj);
    if (!pGameObject)
    {
        return ret;
    }

    if (pGameObject->FindProp(prop_name))
    {
        int prop_type = pGameObject->GetPropType(prop_name);
        if (prop_type == VTYPE_INT)
        {
            ret = (float)pGameObject->QueryPropInt(prop_name);
        }
        else if(prop_type == VTYPE_FLOAT)
        {
            ret = (float)pGameObject->QueryPropFloat(prop_name);
        }
        else if  (prop_type == VTYPE_DOUBLE)
        {
            ret = (float)pGameObject->QueryPropDouble(prop_name);
        }
    }


    float add_value = 0.0f;
    std::string add_prop = std::string(prop_name) + "Add";
    if (pGameObject->FindProp(add_prop.c_str()))
    {
        int prop_type = pGameObject->GetPropType(add_prop.c_str());
        if (prop_type == VTYPE_INT)
        {
            add_value = (float)pGameObject->QueryPropInt(add_prop.c_str());
        }
        else if(prop_type == VTYPE_FLOAT)
        {
            add_value = (float)pGameObject->QueryPropFloat(add_prop.c_str());
        }
        else if  (prop_type == VTYPE_DOUBLE)
        {
            add_value = pGameObject->QueryPropDouble(add_prop.c_str());
        }
    }

    return ret + add_value;
}

float QueryPropValueBySource( const char* prop_name, int source )
{
    float res = 0.0f;

    IGameClient* pGameClient = (IGameClient*)CHelper::GetGameClient();
    PERSISTID obj = pGameClient->GetPlayer();
    IGameObject* pGameObject = (IGameObject*)CHelper::GetEntity(obj);
    if (pGameObject && prop_name && pGameObject->FindRecord("RefreshPropCompute"))
    {
        CVarList result;
        pGameObject->FindRecordRow(CVarList() <<"RefreshPropCompute" << 0 << prop_name, result);
        int row = result.IntVal(0);
        if (row < 0)
        {
            return res;
        }

        int prop_type = pGameObject->GetRecordColType("RefreshPropCompute",source);
        if (prop_type == VTYPE_INT)
        {
            res = (float)pGameObject->QueryRecordInt("RefreshPropCompute", row, source);
        }
        else if (prop_type == VTYPE_FLOAT)
        {
            res = (float)pGameObject->QueryRecordFloat("RefreshPropCompute", row, source);
        }
        else if (prop_type == VTYPE_DOUBLE)
        {
            res = (float)pGameObject->QueryRecordDouble("RefreshPropCompute", row, source);
        }
    }

    return res;
}

!chen
关注
中缀表达式——表达式树
weixin_55835175的博客
09-16 1780
中缀表达式——表达式树 还记得之前讲过的波兰表达式和逆波兰表达式么？我再最后提了一句可以将中缀表达式像以下的方法解析成一个树： 波兰和逆波兰表达式分别是对上面得树进行前序和后序遍历。我们这里的表达式树，就是这个树。我们现在需要学习如何将中缀表达式转化为上面这个树。 代码实现 事实上我们可以简单的总结几个小结论： 1.叶节点一定是数字 2.没有括号的情况下，相对运算优先级低的运算符放在树的上层位置 根据上面的两个结论，我们对建树就有一个粗略的概念了，用l和r分别表示两个端点[l,r)，如果r-l=1，代表
c++实现表达式树
qq_52232093的博客
11-26 1122
因为我不会模板，所以我写了两个stack，一个用来存表达式使其变为后缀，另一用来存Node节点使其变为一棵树，在写的过程中我一直在思考要不要写拷贝和移动构造，最后还是没有写。 1、下面是表达式中缀变后缀的栈的代码： 声明： #pragma once #include <iostream> using namespace std; class MyStack { private: const int DEAFAULT_CAPACITY = 10;/*定义栈初始化长度*/ co
C++实现表达式树
m0_51955470的博客
11-24 1609
代码如下: #include <iostream> #include <string> #include <stack> #include <queue> using namespace std; class Tree { private: class Node { public: char val; Node * left; Node *right; Node(char val):val(val),left(nullptr),rig
C++ 不知树系列之表达式树
y6123236的专栏
10-20 526
得到后缀表达式后，可以直接求值，其实求值过程中已经包括了构建了树的流程，只是没有明说出来。把后缀表达式映射成二叉树，其一，可以通过结构清晰看到后缀表达式的底层逻辑，其一可以基于树的算法直观易懂得到结果。再因节点是可以是复杂数据类型，可以在遍历树的过程中封装复杂的结果。无论如何，把一个抽象的问题变得能具体描述，对于解题是大有帮助的。
你们要的中缀表达式树
fantasydreams的专栏
03-12 2210
你们要的中缀表达式树 Case Time Limit: 100 MS (Others) / 200 MS (Java) Case Memory Limit: 256 MB (Others) / 512 MB (Java) Accepted: 32 Total Submission: 141 查看我的提交显示标签 Problem Description 给定一棵二叉树...
根据表达式序列（前缀、中缀、后缀）构建表达式树
weixin_34248023的博客
01-08 2642
如果输入序列是表达式（前缀表达式、中缀表达式、后缀表达式，中缀表达式要求带括号有几个运算符就带几个）则构建出来的树为表达式树，对该树前、中、后序遍历得到对应序的表达式。 不过，中缀表达式带括号，而表达式树不带括号，故中序遍历表达式树时需要加适当的括号才能得到正确的中缀表达式。 1、表达式树的构建与遍历 0、工具函数（链表节点定义、读取下一个字符、判断字符是否操作数）： 1 typ...
C++中缀表达式转后缀表达式并计算
qq_42999061的博客
12-29 910
关于后缀表达式的计算，参考了此链接，https://blog.csdn.net/creativele/article/details/81710049 栈的应用——四则运算表达式求值。 后缀表达式的优点是所有的符号都是在要运算数字的后面出现，例如简单表达式“1+2”，后缀表达式即为12+。 再如表达式“（3-1）x2”，其后缀表达式为31-2*。 再如表达式“9-3x2”，其后缀表达式为932*-。 中缀表达式转后缀表达式 规则：从左到右遍历中缀表达式的每个数字和符号，若是数字就输出，即成为后缀表达式的一部
中缀表达式构建二叉树以及递归非递归遍历算法
lanshanxunmeng的专栏
03-25 1708
最近准备找实习，发现数据结构也忘得差不多了，重新敲敲代码，回忆回忆，同时也算是一种笔记！ 内容： 输入为以‘#’结束的数学表达式，将表达式在转换为后缀的同时构建表达式二叉树，然后实现树的递归和非递归的遍历。。其中非递归算法，列出了统一的模式和各自的模式！ /*********************************************************************
【C++】后缀表达式转前/中缀表达式 答案（分析构造表达式树的方法）
icykitty的博客
10-30 779
#include &lt;iostream&gt; #include &lt;cstdio&gt; using namespace std; char s[100][20]; int le[100]; /* 方法为构建表达式树： le[i]表示：第i个元素（数/运算符）统领的子表达式的左端点位置。 a.对于一个数，其自身就是叶节点，所以子树就是其自身，左端点位置为其自身。 b.对于一个运...
【C++讨论站】可以完成中缀表达式转后缀表达式的简单计算器
yaoyimingde的博客
12-17 2153
1．问题描述 对于给定的一个表达式，表达式中可以包括常数、算术运行符（包括：“+”、 “-”、“*”、“/”、“%”（求余运算）、“^”（乘幂运算）、“！”（阶乘运算））和括 号，编写一个简单计算器，实现表达式的计算。 基本要求：从键盘输入一个正确的表达式，将表达式转换为对应的后缀表达式，并计算后缀 表达式的值。对于表达式中的简单错误（如，除数不能为零、负数无法求阶乘等），能够给出提 示，并给出错误信息；表达式中可以包括单个字母表示的变量。 提高要求：完成基本要求的基础上，能够支持一部分不规范的表达式
c++ 数据结构 表达式树算法
09-10
此程序是用C++实现的，完全用模板结构实现的。绝对是值得查阅的。
中缀表达式树以及利用中缀表达式树求值
05-19
将简单的中缀表达式转换成表达式树，然后利用表达式树对中缀表达式进行求值。
C++前中后缀表达式转表达式二叉树
05-17
选择输入前中后缀表达式，建立表达式二叉树，再前序中序后序遍历二叉树，输出三种形式的表达式
c++ 计算表达式结果（二叉树、后缀表达式）
07-26
将中缀表达式转换为二叉树、后序遍历二叉树转为后缀表达式、计算后缀表达式
基于C++进行表达式树的建立和遍历(高级语言程序设计实验)
06-30
在本实验中，我们将深入探讨如何使用C++编程语言来构建和遍历表达式树，这是高级语言程序设计中的一项重要技术。表达式树是一种数据结构，它将中缀表达式转换为直观的树状形式，便于计算和操作。下面我们将详细讲解...
C++构建算术表达式二叉树
敢于知道,
11-10 2419
#include <iostream> #include <string> using namespace std; #define MaxSize 30 //树节点信息 struct TreeNode { char val; TreeNode *left; TreeNode *right; TreeNode(char x = '\0'...
表达式建树
weixin_33874713的博客
11-15 253
//用数组实现树 #include<iostream> #include<ctype.h> #include<cstring> #define N 10000 #define optd 1 #define optr 2 using namespace std; int treeL[N], treeR[N]; cla...
C++ - 表达式二叉树
biaogexf
04-20 2462
问题描述与解题思路与我之前用C语言写过的博客一模一样，这里这不过是用面向对象的思想以C++语言的方式再次呈现一遍。C语言版本：点击打开链接https://blog.csdn.net/y_16041527/article/details/79835727So......这里直接上C++的完整代码头文件声明：//BinaryTree.h #include &lt;iostream&gt; const...
表达式树---中缀表达式转后缀表达式
笑面蘑菇的博客
08-25 626
** 题目描述 ** 给定中缀表达式（只限 + - * / （） 和 小写字母），求其后缀表达式。 分析 关于中缀表达式的处理，有两种方法，一是用双栈处理，二是先建立一颗表达式树，再对其进行遍历处理。 本文讲述后者的方法 前序遍历 –&amp;amp;amp;gt; 前缀表达式（波兰式） 中序遍历 –&amp;amp;amp;gt; 中缀表达式 后序遍历 –&amp;amp;amp;gt; 后缀表达式（逆波兰式） ...
中缀表达式 建树 代码c++
最新发布
10-13
中缀表达式是一种常见的数学表示法，如 "3 + 4 * 5"，其中操作符位于两个操作数之间。要将这种表达式转换成计算机可以理解的形式（通常是后缀或前缀表达式），我们通常会使用一种称为“解析”的过程，然后构建一棵被称为算术表达式树的数据结构。 在C++中，我们可以创建一个二叉树来表示中缀表达式，每个节点代表一个运算符或操作数。下面是一个简单的步骤说明： 1. **定义节点**：首先，我们需要定义一个`TreeNode`类，包含左、右子节点和一个存储操作数或运算符的字段。 ```cpp struct TreeNode { char value; // 操作数或运算符 TreeNode* left; TreeNode* right; }; ``` 2. **推导表达式树**：从左到右遍历中缀表达式，遇到操作数就创建新节点并添加到当前节点的左侧；遇到运算符则创建新的节点，将其设置为当前节点的右侧，并更新当前节点为新节点。 3. **构建函数**：编写一个递归函数，接受中缀表达式的字符串和开始索引作为输入，返回根节点。 ```cpp TreeNode* buildTree(string& infix, int start) { // ... 这里实现具体的解析算法 } ``` 4. **打印表达式树**：最后，你可以创建一个辅助函数用于遍历和打印这个表达式树。 ```cpp void printInfix(TreeNode* root) { // ... 使用中序遍历或其他适合的方法打印节点值 } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

!chen

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

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

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

打赏作者

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

抵扣说明：

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

余额充值