栈和二叉树的使用--四则运算

最新推荐文章于 2022-12-15 20:53:10 发布
最新推荐文章于 2022-12-15 20:53:10 发布
阅读量5.5k 收藏 9
点赞数 3
分类专栏： C/C++ 数据结构与算法 C++模板
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhx6044/article/details/8922472
版权

                   使用栈来检测表达式括号的匹配，使用二叉树来保存运算的中缀表达式，对表达式树进行后序遍历得到后缀表达式，运算得到表达式的值。

                   检测配对使用栈保存‘（’符号，当遇到一个‘）’，出栈，若栈空则出错，表达式结束，栈非空也出错。

                  

                   3*5+2构造二叉树如下

                  


                    四则运算有优先级和结合关系，在构造二叉树时影响构造的过程。优先级高的运算符深度较深，在后序遍历时，先遍历到。

                    2+3*5构造二叉树如下

    


          遇到括号，将括号中的看成一个子运算式，使用递归来解决。

         在中缀表达式转换事的算法描述如下：

         当当前的符号是运算数时，检测当前是否有树根，没有则作为树根，否则作为前一个运算符的右孩子，当根节点没有右孩子则作为右孩子，有右孩子则作为右孩子的右元算数。如果是+或-，那它就是已知的最后一个运算符，将它作为根节点，原来的树作为左子树。如果是*或/，优先级高，就要和根节点做比较，怎么改变。如根节点是+或-，则则应该先运算，所以作为右子树的根节点，原来的子树作为它的左子树。如果是同优先级的，原来的先计算，当前最为根节点，原来作为左子树。

         

#ifndef EXCEPTIONS_H
#define EXCEPTIONS_H

#include <exception>
#include <iostream>

/**
 * @brief The OutOfBoundary class 越界异常
 */
class OutOfBoundary : public std::exception
{
    friend std::ostream& operator << (std::ostream& os, const std::exception &obj) {
        os << obj.what();
        return os;
    }

public:
    OutOfBoundary() throw(): exception(){}
    ~OutOfBoundary() throw(){}

    const char* what() const throw(){
        return "out of boundary!";
    }

};
/**
 * @brief The BadValue class 坏值异常
 */
class BadValue : public std::exception
{
    friend std::ostream& operator << (std::ostream& os, const BadValue &obj) {
        os << obj.what();
        return os;
    }
public:
    BadValue() throw(): exception(){}
    ~BadValue() throw(){}
    const char* what() const throw(){
        return "bad value!";
    }

};

class MyException : public std::exception
{
public:
    MyException(const char *_mes) throw() : exception(),info(_mes) {}
    ~MyException() throw(){}
    const char * what() const throw() {
        return info.data();
    }

private:
    std::string info;

};




#endif


#ifndef BALANCE_HPP
#define BALANCE_HPP

#include "linkStack.hpp"

class Balance
{
public:
    enum elemType{OPAREN,CPAREN,OTHER,EOL};
    Balance(const char* ex);
    ~Balance(){}
    bool balance();
private:
    LinkStack<char> _stack;
    const char * _ex;
    elemType getToken();
};

inline
Balance::Balance(const char *ex) : _ex(ex)
{

}

bool Balance::balance()
{
    elemType t = getToken();
    while (t != EOL) {
        switch (t) {
        case OPAREN:
            _stack.push('(');
            break;
        case CPAREN:
            if (_stack.isEmpty()) {
                return false;
            } else {
                _stack.pop();
            }
            break;
        default:
            break;
        }
        t = getToken();
    }

    return _stack.isEmpty(); \
}

Balance::elemType Balance::getToken()
{
    elemType re;

    while(*_ex == ' ') ++_ex;

    if (*_ex >= '0' && *_ex <= '9') {
        while(*_ex >= '0' && *_ex <= '9') {
            ++_ex;
        }
        return OTHER;
    }

    switch (*_ex++) {
    case '(':
        re = OPAREN;
        break;
    case ')':
        re = CPAREN;
        break;
    case '\0':
        re = EOL;
        break;
    default:
        re = OTHER;
        break;
    }
    return re;
}

#endif // BALANCE_HPP


#ifndef CALCULATOR_HPP
#define CALCULATOR_HPP

#include "balance.hpp"
#include "exceptions.hpp"

template <typename T>
class Calculator
{
public:
    /**
     * @brief The elemType enum
     * 数字 加 减 乘 除 开括号open  闭括号close 结束标识
     */
    enum elemType{DATA, ADD, SUB, MULIT, DIV, OPAREN, CPAREN, EOL};
    Calculator(char *ex);
    ~Calculator() {
        destroy(root);
    }
    T result();
private:
    struct node {
        elemType type;
        T data;
        node *lc, *rc;
        node(elemType _type, T _data, node *_lc = 0, node *_rc = 0):
            type(_type),
            data(_data),
            lc(_lc),
            rc(_rc) {

        }
    };

    node *create(char *&ex);
    elemType getToken(char *&ex, T &value);
    void destroy(node *r);
    T result(node *r);

    node *root;
};

template <typename T>
Calculator<T>::Calculator(char *ex)
{
    Balance b(ex);
    if (!b.balance()) {
        throw MyException("() not match!!!");
    }
    root = create(ex);
}

template <typename T>
void Calculator<T>::destroy(node *r)
{
    if (r != NULL) {
        destroy(r->lc);
        destroy(r->rc);
        delete r;
    }
}
template <typename T>
typename Calculator<T>::node* Calculator<T>::create(char *&ex)
{
    node* p, *root = 0;
    elemType reType;
    T value;
    while(*ex) {
        reType = getToken(ex,value);
        switch (reType) {
        case DATA:
        case OPAREN:
            if(reType == DATA) {
                p = new node(DATA,value);
            } else {
                /**
                  解决这样情况
                  (4-2)*5
                  树形结构为

                    |------|                         |------|
                    | _ |        *                 | _ |
                    |------|    --------------->          |------|     (X)
                     |    \                        |    \
                     |     \                       |     \
                  |------|    |-----|                   |------|    |-----|
                  | 4 |     |   2 |                | 4 |     |   * |
                  |------|    |-----|                  |------|    |-----|
                                                          |     \
                                                          |      \
                                                       |------|   |------|
                                                       |2  |     |  5  |
                                                      |------|      |------|




                  ***/
                p = create(ex);
                node *q = new node(DATA,result(p));
                destroy(p);
                p = q;
            }
            if (root == NULL) {
                root = p;
            } else {
                if (root->rc == NULL) {
                    root->rc = p;
                } else {
                    root->rc->rc = p;
                }
            }
            break;
        case CPAREN:
        case EOL:
            return root;
        case ADD:
        case SUB:
            root = new node(reType,0,root);
            break;
        case MULIT:
        case DIV:
            if (root->type == DATA || root->type == MULIT || root->type == DIV) {
                root = new node(reType,0,root);
            } else {
                root->rc = new node(reType,0,root->rc);
            }
            break;
        default:
            return NULL;
            break;
        }

    }
    return root;
}

template <typename T>
typename Calculator<T>::elemType Calculator<T>::getToken(char *&ex, T &value)
{
    char t;
    while(*ex == ' ') ++ex;
    if (*ex >= '0' && *ex <= '9') {
        value = 0;
        while(*ex >= '0' && *ex <= '9') {
            value = value*10 + *ex - '0';
            ++ex;
        }
        return DATA;
    }

    if (*ex == '\0') return EOL;
    t = *ex;
    ++ex;
    switch (t) {
    case '+':
        return ADD;
    case '-':
        return SUB;
    case '*':
        return MULIT;
    case '/':
        return DIV;
    case '(':
        return OPAREN;
    case ')':
        return CPAREN;
    default:
        return EOL;
    }

}

template <typename T>
T Calculator<T>::result()
{
    return result(root);
}

template <typename T>
T Calculator<T>::result(node *r)
{
    elemType t = r->type;
    T t2,t3;
    if (t == DATA) {
        return r->data;
    }
    t2 = result(r->lc);
    t3 = result(r->rc);
    switch (t) {
    case ADD:
        r->data = t2 + t3;
        break;
    case SUB:
        r->data = t2 - t3;
        break;
    case MULIT:
        r->data = t2 * t3;
        break;
    case DIV:
        r->data = t2 / t3;
        break;
    default:
        break;
    }
    return r->data;
}

#endif // CALCULATOR_HPP


int main()
{
    try {
        Calculator<int> ex("(4-2)*(10+(4+6)/2)+2");
        std::cout << ex.result();
    } catch(std::exception &ex) {
        std::cout << ex.what() << std::endl;
    }



    return 0;
}


修复一个bug，可以处理小数，不过不进行检错

template <typename T>
typename Calculator<T>::elemType Calculator<T>::getToken(char *&ex, T &value)
{
    char t;
    while(*ex == ' ') ++ex;
    if (*ex >= '0' && *ex <= '9') {
        value = 0;
        T t = 0;
        T t2 = 1;
        bool f = false;//标识小数点
        while((*ex >= '0' && *ex <= '9') || *ex == '.' ) {
            if (*ex == '.') {
                f = true;
                ++ex;
                continue;
            }
            if (!f) {
                value = value*10 + *ex - '0';
            } else {
                t2 *= 0.1;
                t = t + (*ex - '0')*t2;
            }
            
            ++ex;
        }
        value += t;
        return DATA;
    }
    
    if (*ex == '\0') return EOL;
    t = *ex;
    ++ex;
    switch (t) {
    case '+':
        return ADD;
    case '-':
        return SUB;
    case '*':
        return MULIT;
    case '/':
        return DIV;
    case '(':
        return OPAREN;
    case ')':
        return CPAREN;
    default:
        return EOL;
    }
    
}


修复bug


Balance::elemType Balance::getToken()
{
    elemType re;

    while(*_ex == ' ') ++_ex;

    //这段代码注释掉没有影响，但是会增加函数的调用，性能会受影响
    if (*_ex >= '0' && *_ex <= '9') {
        while((*_ex >= '0' && *_ex <= '9') || *_ex == '.') {
            ++_ex;
        }
        return OTHER;
    }

    switch (*_ex++) {
    case '(':
        re = OPAREN;
        break;
    case ')':
        re = CPAREN;
        break;
    case '\0':
        re = EOL;
        break;
    default://这边处理所有的不是‘（’‘）’‘\0’的情况，不过函数会返回字符串长度+1次
        re = OTHER;
        break;
    }
    return re;
}

template <typename T>
Calculator<T>::Calculator(char *ex) : root(0), _ex(ex)
{
    //    Balance b(ex);
    //    if (!b.balance()) {
    //        throw MyException("() not match!!!");
    //    }
    //在构造函数中爆出异常回导致析构函数不能调用
    //    root = create(ex);
}



template <typename T>
T Calculator<T>::result()
{
    Balance b(_ex);
    if (!b.balance()) {
        throw MyException("() not match!!!");
    }
    root = create(_ex);
    return result(root);
}

_ex为添加的数据成员




写了程序换酒钱
关注
  • 3
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构】【栈（stack）应用】四则运算表达式求值（支持括号、负数）
crr411422的博客
04-22 1万+
更新留言： 本来是侧重演示栈结构的使用，后面评论区发现很多朋友对这个四则运算比较感兴趣，特此做了更新，新增了对负数的运算支持。 若您也有新的想法或者需求，请在评论区留言，我将尽可能的实现。需要代码的朋友请直接在章末获取。 再次感谢您的阅览，谢谢！（更新时间2023年12月05日）
C/C++ 四则运算（带括号）
weixin_45893253的博客
08-07 5372
C++四则运算实现过程： 实现过程： 先将中缀表达式转换为后缀表达式 例如： 中缀表达式：2*3+（5-4） 后缀表达式：23*54-+ 2.转换实现过程 1.利用栈结构进行转换 2.创建两个栈结构，一个是用来存临时符号，一个是用来存中缀表达式 //转换规则 //1 从左到右遍历 //2 运算数直接输出(压入中缀表达式栈） //3 碰到符号，比较符号栈里面元素的优先级 //3 优先级高于符号栈里面元素则压入符号栈， // 反之，推出符号栈顶元素到存中缀表达式的栈，依次比较，直到 //
二叉树的遍历算法栈c语言,与栈结合的二叉树遍历（c语言）
weixin_35076990的博客
05-23 254
#include #include #define OK 1#define ERROR 0#define OVERFLOW -1#define STACK_INIT_SIZE 100#define maxsize 60typedef int Status;typedef struct BitNode{char data;struct BitNode *lchild ,*rchild;}BitNod...
栈的基本操作和二叉排序树的建立
最新发布
2202_75864093的博客
12-15 186
编写一个程序实现链栈的各种基本运算，并在此基础上设计一个主程序，完成初始化链栈;1、巩固和加深对数据结构课程基本知识的理解，综合数据结构课程里学的理论知识，完成对排序二叉树程序的设计。2、理解和掌握二叉树的各种基本数据结构的定义、存储结构和相应的算法，并能够用c语言实现。学号:2103101021 姓名:杨富华 博客名：深秋雾很淡。3、理解排序二叉树的建立过程。(1)栈的顺序表示和实现。(2)栈的链式表示和实现。
表达式二叉树（使用栈）
yingguoyouzheng的博客
01-15 942
前言 这一次上机的题目就是将表达式二叉树进行相互转换。上一次说到了中缀表达式转后缀表达式，而这次是表达式二叉树转换成前中后缀表达式，只需要改变遍历方式即可。但是老师要只能使用栈。所以就需要保存结点。 需求分析 输入任意的前中后缀表达式，所以需要判断是哪一种表达式。 根据不同的表达式，建立同样的二叉树。再将二叉树表示出来。 按照用户输入，将二叉树转换成对应的表达式输出。 程序功能 将表达式转换成...
二叉树求四则运算
06-26
"二叉树求四则运算" 在数据结构中，二叉树是一种常用的数据结构，它可以用来解决各种问题，例如四则运算。在本实验中，我们使用C/...本实验使用二叉树来解决四则运算问题，展示了二叉树在解决计算问题中的优点和优势。
二叉树解决四则运算问题
04-12
在本课程设计中，主题是使用二叉树解决四则运算问题，主要目的是让学生通过实践了解和掌握软件开发的全过程，包括系统分析、编码设计、系统集成和调试分析。此外，设计要求是实现一个能够处理整数和浮点数的四则运算...
c#实现四则混合运算
12-13
最后，通过遍历后缀表达式，我们可以用栈来实现四则运算。当遇到数字时，将其压入栈；当遇到运算符时，弹出栈顶的两个元素进行运算，并将结果压回栈。这样，我们就可以逐个处理表达式中的运算符，最终得到计算结果。...
数据结构实验三-二叉树基本操作及运算实验报告.docx
10-27
本实验主要关注二叉树的基本操作和运算，包括建立、遍历、计算属性以及进行查找和删除操作。 首先，要理解二叉树的定义。一个二叉树是由节点（或称为结点）构成的，每个节点可以有最多两个子节点，分别称为左子节点...
基于二叉树的四则运算.zip
08-30
C语言编写的二叉树四则运算器，可以将输入的四则表达式转化为二叉树，再通过遍历进行数学上的计算，最终得到结果，内含有良好的交互式界面，可以通过指令测试程序，可用于展示给其他人看。代码格式规范，有大量注释。
二叉树四则运算
04-28
二叉树四则运算,简单的代码运行，熟练运用二叉树问题
栈与二叉树
01-17
用非递归实现对二叉树的操作，循环建立一个有序二叉树，栈遍历二叉树，前序，中序，后序，层序
利用二叉树实现简单的四则运算
qq_53290491的博客
12-08 2387
利用二叉树实现简单的四则运算 在这颗树中,先出来的符号代表着他的优先级越低 所以,我们在将一串表达式输入到字符串中以后,首先要找的是最低优先级的 也就是加减…以此类推,根据 BiTree CreatTree(char s[],int i,int j) //生成表达式二叉树 { //动态生成的树节点 BiTree p,t; //动态申请二叉树的根结点 int k, flag = 0, pos,x=0; int m=-1,n=-1,num=0; //m,n代表左右括号
【栈、队列与二叉树】
m0_70964767的博客
08-06 1176
只能允许在容器的一端(称为栈顶端指标—— top) 进行加入数据(push)和输出数据(pop) 的运算。（5）对完全二叉树，若从上至下、从左至右编号，则编号为i的结点，其左孩子编号必为2i，其右孩子编号必为2i+1;（3）平衡二叉树(AVL树) :当且仅当任何节点的两棵子树的高度差不大于1的二叉树。（1）完全二叉树:对于一颗二叉树，假设其深度为d(d>1)，除了第d层外，其它各。（1）在二叉树的第i层上至多有2^(i-1)个节点(i>0)的原理简称，允许插入的一端为队尾，允许删除的一端为队头。......
利用二叉树计算四则运算表达式
03-19 8402
先做个简单实现，没有括号，所有数字都是个位数 主要思路如下： 例如有这样一个四则运算表达式 2+3*4/2-3+1 先将其分成两部分的和： 2+3*4/2-3     +    1 +号作为二叉树的根，左右两部分分别作为二叉树根的左右子树 再依次递归的分下去。 最终将其转化为下面这样的一棵树：
用栈实现二叉树的遍历——前序，中序，后序
四川兔兔的博客
01-03 6202
详细教学Java用栈来实现二叉树的遍历，前序，后序，中序遍历
二叉树计算四则运算表达式
学海无涯 苦写博客
07-09 7698
转自：http://blog.csdn.net/a477997/article/details/7369151 1 * 2 / ( ( 3 + 4 ) * ( - 5 + 6 ) ) 这样一个式子，采用二叉树实现四则运算，需要使用递归的思想。总共分两步，第一步是建立二叉树，第二步是计算。 建立二叉树： 将式子存入一个char[] expresstion中，然后带入一个消除多余括号的函数
栈的应用---四则运算表达式求值
michael019的博客
06-30 629
栈的应用—四则运算表达式求值 概念:二叉树的三种表达方式，前序（根-左-右），中序（左-根-右），后序（左-右-根）——分别对应前缀，中缀，后缀表达式 栈的应用：对后缀表达式进行计算 原理：将中缀表达式转到后缀表达式 步骤1：根据中缀表达式画出二叉树（关键所在） 步骤2：后序遍历方式遍历当前二叉树，得到后缀表达式 步骤3：计算后缀表达式，计算规则：从左到右遍历表达式的每个数字及符号，遇到数字则进栈，
二叉树和栈的基本操作
wolfGuiDao的博客
10-23 2410
二叉树和栈的基本操作 Tree.h： #pragma once #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <stdlib.h> #include <assert.h> #define TreeDataType char /**二叉树数据结构定义**/ typedef struct...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值