计算器核心解析算法

最新推荐文章于 2024-02-29 22:21:16 发布
最新推荐文章于 2024-02-29 22:21:16 发布
阅读量1.7k 收藏 11
点赞数 3
分类专栏： QT【笔记】
课程笔记内容整理于狄泰软件
本文链接：https://blog.csdn.net/qq_39654127/article/details/81036711
版权

上节实现了计算器的界面，这节实现核心算法，下节实现用户界面与业务逻辑的分离

目录

1、分离算法

2、括号匹配算法 

3、中缀转后缀算法

4、后缀表达式计算 

5、完整代码

分离算法：将中缀表达式进行数字和运算符的分离 

中缀转后缀算法：将中缀表达式转换为后缀表达式 

后缀表达式计算 ：通过后缀表达式计算最终结果 

1、分离算法

思想：以符号作为标志对表达式中的字符逐个访问

    - 初始累计变量num为空，遍历字符串每个字符

    - 若遇到数字或小数点（即当前符号是数字的一部分），累加到num变量，并用pre变量记录当前符号（用来判断正负号）

    - 若遇到其它符号（+， -， *， / ， ( ， ) ，+， -）

         ✔ 先看num变量，若有值，num的值放入队列，清空num

         ✔ 若为正负号，累计到num变量（流程能走到这说明num无值）

         ✔ 否则当前字符（即运算符或括号）入队列

         ✔ pre记录当前字符

    - 遍历结束后若num不为空，入队列（遍历的最后一个字符是数字还没机会入队列）

 

  

区分正负号和加减号准则：正负号 + 和 - 在表达式的第一个位置、括号后的 + 和 - 、运算符后的 + 和 -

bool QCalculatorDec::isDigitOrDot(QChar c)
{
    return (('0' <= c) && (c <= '9')) || (c == '.');
}

bool QCalculatorDec::isSymbol(QChar c)
{
    return isOperator(c) || (c == '(') || (c == ')');
}

bool QCalculatorDec::isSign(QChar c)
{
    return (c == '+') || (c == '-');
}

bool QCalculatorDec::isNumber(QString s)
{
    bool ret = false;

    s.toDouble(&ret);

    return ret;
}

bool QCalculatorDec::isOperator(QString s)
{
    return (s == "+") || (s == "-") || (s == "*") || (s == "/");
}

bool QCalculatorDec::isLeft(QString s)
{
    return (s == "(");
}

bool QCalculatorDec::isRight(QString s)
{
    return (s == ")");
}

int QCalculatorDec::priority(QString s)
{
    int ret = 0; // 其他符号的优先级最低

    if( (s == "+") || (s == "-") )
    {
        ret = 1;
    }

    if( (s == "*") || (s == "/") )
    {
        ret = 2;
    }

    return ret;
}

QQueue<QString> QCalculatorDec::split(const QString& exp)
{
    QQueue<QString> ret;
    QString num = "";
    QString pre = "";

    for(int i=0; i<exp.length(); i++)
    {
        if( isDigitOrDot(exp[i]) )
        {
            num += exp[i];
            pre = exp[i];
        }
        else if( isSymbol(exp[i]) )
        {
            if( !num.isEmpty() )
            {
                ret.enqueue(num);

                num.clear();
            }

            if( isSign(exp[i]) && ((pre == "") || (pre == "(") || isOperator(pre)) )
            {
                num += exp[i];
            }
            else
            {
                ret.enqueue(exp[i]);
            }

            pre = exp[i];
        }
    }

    if( !num.isEmpty() )
    {
        ret.enqueue(num);
    }

    return ret;
}

 

2、括号匹配算法 

合法的四则运算表达式中 ，括号匹配成对出现 ，左括号必然先于右括号出现

          

bool QCalculatorDec::match(QQueue<QString>& exp)
{
    bool ret = true;
    int len = exp.length();
    QStack<QString> stack;

    for(int i=0; i<len; i++)
    {
        if( isLeft(exp[i]) )
        {
            stack.push(exp[i]);
        }
        else if( isRight(exp[i]) )
        {
            if( !stack.isEmpty() && isLeft(stack.top()) )
            {
                stack.pop();
            }
            else
            {
                ret = false;
                break;
            }
        }
    }

    return ret && stack.isEmpty();
}

3、中缀转后缀算法

中缀表达式：9.3 + ( 3 - -0.11 ) * 5 + 10

后缀表达式：9.3    3     -0.11    -      5     *    10     +    +

流程：

  • 9.3 为数字，直接输出
  • + 为运算符且栈为空，入栈
  • (  为左括号，入栈
  • 3是数字，直接输出
  • - 是运算符，大于栈顶优先级，入栈
  • -0.11 是数字，直接输出
  • )  为右括号，不断弹出栈顶，直到遇到左括号与当前的右括号匹配
  • * 为运算符，大于栈顶优先级，入栈（后缀的表现形式为 num1 num2 op， 运算符始终在最后，当前的运算符优先级高， 先参与计算 ）
  • 5 为数字，直接输出
  • + 为运算符，小于栈顶优先级，栈顶出栈输出，+入栈（后缀的表现形式为 num1 num2 op， 运算符始终在最后，当前的运算符优先级低， 后参与计算 ）
  • 10是数字，直接输出
  • 此时栈不为空，全部输出

验证：从左到右分别将操作符的左边的两个数字与操作符进行运算

转换过程： 

    - 当前元素e为数字，输出到队列 

    - 当前元素e为运算符： 先与栈顶运算符进行优先级比较 

             ✔ 小于等于：将栈顶元素输出到队列

             ✔ 将当前元素e入栈 

    - 当前元素e为左括号：入栈 

    - 当前元素e为右括号： 

         1. 弹出栈顶元素并输出到队列，直至栈顶元素为左括号 

         2. 将栈顶的左括号从栈中弹出

bool QCalculatorDec::transform(QQueue<QString>& exp, QQueue<QString>& output)
{
    bool ret = match(exp);
    QStack<QString> stack;

    output.clear();

    while( ret && !exp.isEmpty() )
    {
        QString e = exp.dequeue();

        if( isNumber(e) )
        {
            output.enqueue(e);
        }
        else if( isOperator(e) )
        {
            while( !stack.isEmpty() && (priority(e) <= priority(stack.top())) )
            {
                output.enqueue(stack.pop());
            }

            stack.push(e);
        }
        else if( isLeft(e) )
        {
            stack.push(e);
        }
        else if( isRight(e) )
        {
            while( !stack.isEmpty() && !isLeft(stack.top()) )
            {
                output.enqueue(stack.pop());
            }

            if( !stack.isEmpty() )
            {
                stack.pop();
            }
        }
        else
        {
            ret = false;
        }
    }

    while( !stack.isEmpty() )
    {
        output.enqueue(stack.pop());
    }

    if( !ret )
    {
        output.clear();
    }

    return ret;
}

 

4、后缀表达式计算 

遍历后缀表达式中的数字和运算符 

    - 当前元素为数字，进栈 

    - 当前元素为运算符： 

         1. 从栈中弹出右操作数 

         2. 从栈中弹出左操作数 

         3. 根据符号进行运算 

         4 将运算结果压入栈中 

遍历结束 

    - 栈中的唯一数字为运算结果

QString QCalculatorDec::calculate(QString l, QString op, QString r)
{
    QString ret = "Error";

    if( isNumber(l) && isNumber(r) )
    {
        double lp = l.toDouble();
        double rp = r.toDouble();

        if( op == "+" )
        {
            ret.sprintf("%f", lp + rp);
        }
        else if( op == "-" )
        {
            ret.sprintf("%f", lp - rp);
        }
        else if( op == "*" )
        {
            ret.sprintf("%f", lp * rp);
        }
        else if( op == "/" )
        {
            const double P = 0.000000000000001;

            if( (-P < rp) && (rp < P) )
            {
                ret = "Error";
            }
            else
            {
                ret.sprintf("%f", lp / rp);
            }

        }
        else
        {
            ret = "Error";
        }
    }

    return ret;
}

QString QCalculatorDec::calculate(QQueue<QString>& exp)
{
    QString ret = "Error";
    QStack<QString> stack;

    while( !exp.isEmpty() )
    {
        QString e = exp.dequeue();

        if( isNumber(e) )
        {
            stack.push(e);
        }
        else if( isOperator(e) )
        {
            QString rp = !stack.isEmpty() ? stack.pop() : "";
            QString lp = !stack.isEmpty() ? stack.pop() : "";
            QString result = calculate(lp, e, rp);

            if( result != "Error" )
            {
                stack.push(result);
            }
            else
            {
                break;
            }
        }
        else
        {
            break;
        }
    }

    if( exp.isEmpty() && (stack.size() == 1) && isNumber(stack.top()) )
    {
        ret = stack.pop();
    }

    return ret;
}

5、完整代码

QCalculatorDec.h

#ifndef _CALCULATORCORE_H_
#define _CALCULATORCORE_H_

#include <QString>
#include <QStack>
#include <QQueue>

class QCalculatorDec
{
protected:
    QString m_exp;
    QString m_result;

    bool isDigitOrDot(QChar c);
    bool isSymbol(QChar c);
    bool isSign(QChar c);
    bool isNumber(QString s);
    bool isOperator(QString s);
    bool isLeft(QString s);
    bool isRight(QString s);
    int priority(QString s);
    bool match(QQueue<QString>& exp);
    QString calculate(QQueue<QString>& exp);
    QString calculate(QString l, QString op, QString r);
    bool transform(QQueue<QString>& exp, QQueue<QString>& output);
    QQueue<QString> split(const QString& exp);
public:
    QCalculatorDec();
    ~QCalculatorDec();
    bool expression(const QString& exp);
    QString expression();
    QString result();
};

#endif

QCalculatorDec.cpp

#include "QCalculatorDec.h"

QCalculatorDec::QCalculatorDec()
{
    m_exp = "";
    m_result = "";
}

QCalculatorDec::~QCalculatorDec()
{

}

bool QCalculatorDec::isDigitOrDot(QChar c)
{
    return (('0' <= c) && (c <= '9')) || (c == '.');
}

bool QCalculatorDec::isSymbol(QChar c)
{
    return isOperator(c) || (c == '(') || (c == ')');
}

bool QCalculatorDec::isSign(QChar c)
{
    return (c == '+') || (c == '-');
}

bool QCalculatorDec::isNumber(QString s)
{
    bool ret = false;

    s.toDouble(&ret);

    return ret;
}

bool QCalculatorDec::isOperator(QString s)
{
    return (s == "+") || (s == "-") || (s == "*") || (s == "/");
}

bool QCalculatorDec::isLeft(QString s)
{
    return (s == "(");
}

bool QCalculatorDec::isRight(QString s)
{
    return (s == ")");
}

int QCalculatorDec::priority(QString s)
{
    int ret = 0;

    if( (s == "+") || (s == "-") )
    {
        ret = 1;
    }

    if( (s == "*") || (s == "/") )
    {
        ret = 2;
    }

    return ret;
}

bool QCalculatorDec::expression(const QString& exp)
{
    bool ret = false;
    QQueue<QString> spExp = split(exp);
    QQueue<QString> postExp;

    m_exp = exp;

    if( transform(spExp, postExp) )
    {
        m_result = calculate(postExp);

        ret = (m_result != "Error");
    }
    else
    {
        m_result = "Error";
    }


    return ret;
}

QString QCalculatorDec::result()
{
    return m_result;
}

QQueue<QString> QCalculatorDec::split(const QString& exp)
{
    QQueue<QString> ret;
    QString num = "";
    QString pre = "";

    for(int i=0; i<exp.length(); i++)
    {
        if( isDigitOrDot(exp[i]) )
        {
            num += exp[i];
            pre = exp[i];
        }
        else if( isSymbol(exp[i]) )
        {
            if( !num.isEmpty() )
            {
                ret.enqueue(num);

                num.clear();
            }

            if( isSign(exp[i]) && ((pre == "") || (pre == "(") || isOperator(pre)) )
            {
                num += exp[i];
            }
            else
            {
                ret.enqueue(exp[i]);
            }

            pre = exp[i];
        }
    }

    if( !num.isEmpty() )
    {
        ret.enqueue(num);
    }

    return ret;
}

bool QCalculatorDec::match(QQueue<QString>& exp)
{
    bool ret = true;
    int len = exp.length();
    QStack<QString> stack;

    for(int i=0; i<len; i++)
    {
        if( isLeft(exp[i]) )
        {
            stack.push(exp[i]);
        }
        else if( isRight(exp[i]) )
        {
            if( !stack.isEmpty() && isLeft(stack.top()) )
            {
                stack.pop();
            }
            else
            {
                ret = false;
                break;
            }
        }
    }

    return ret && stack.isEmpty();
}

bool QCalculatorDec::transform(QQueue<QString>& exp, QQueue<QString>& output)
{
    bool ret = match(exp);
    QStack<QString> stack;

    output.clear();

    while( ret && !exp.isEmpty() )
    {
        QString e = exp.dequeue();

        if( isNumber(e) )
        {
            output.enqueue(e);
        }
        else if( isOperator(e) )
        {
            while( !stack.isEmpty() && (priority(e) <= priority(stack.top())) )
            {
                output.enqueue(stack.pop());
            }

            stack.push(e);
        }
        else if( isLeft(e) )
        {
            stack.push(e);
        }
        else if( isRight(e) )
        {
            while( !stack.isEmpty() && !isLeft(stack.top()) )
            {
                output.enqueue(stack.pop());
            }

            if( !stack.isEmpty() )
            {
                stack.pop();
            }
        }
        else
        {
            ret = false;
        }
    }

    while( !stack.isEmpty() )
    {
        output.enqueue(stack.pop());
    }

    if( !ret )
    {
        output.clear();
    }

    return ret;
}

QString QCalculatorDec::calculate(QString l, QString op, QString r)
{
    QString ret = "Error";

    if( isNumber(l) && isNumber(r) )
    {
        double lp = l.toDouble();
        double rp = r.toDouble();

        if( op == "+" )
        {
            ret.sprintf("%f", lp + rp);
        }
        else if( op == "-" )
        {
            ret.sprintf("%f", lp - rp);
        }
        else if( op == "*" )
        {
            ret.sprintf("%f", lp * rp);
        }
        else if( op == "/" )
        {
            const double P = 0.000000000000001;

            if( (-P < rp) && (rp < P) )
            {
                ret = "Error";
            }
            else
            {
                ret.sprintf("%f", lp / rp);
            }

        }
        else
        {
            ret = "Error";
        }
    }

    return ret;
}

QString QCalculatorDec::calculate(QQueue<QString>& exp)
{
    QString ret = "Error";
    QStack<QString> stack;

    while( !exp.isEmpty() )
    {
        QString e = exp.dequeue();

        if( isNumber(e) )
        {
            stack.push(e);
        }
        else if( isOperator(e) )
        {
            QString rp = !stack.isEmpty() ? stack.pop() : "";
            QString lp = !stack.isEmpty() ? stack.pop() : "";
            QString result = calculate(lp, e, rp);

            if( result != "Error" )
            {
                stack.push(result);
            }
            else
            {
                break;
            }
        }
        else
        {
            break;
        }
    }

    if( exp.isEmpty() && (stack.size() == 1) && isNumber(stack.top()) )
    {
        ret = stack.pop();
    }

    return ret;
}

main.cpp

#include <QtGui/QApplication>
#include "QCalculatorDec.h"

#include <QDebug>

int main(int argc, char *argv[])
{
    
    QCalculatorDec c;

    c.expression(" (5 - 8) * (5 - 6) ");

    qDebug() << c.result();

    return 0;
}

 

洋葱汪
关注
  • 3
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
labview计算器（算法类）
10-28
在LabVIEW中构建计算器，开发者首先需要理解数据流编程的概念，这是LabVIEW的核心编程方式。在这个模型中，程序的执行依赖于数据的流动，而不是传统的控制流程。通过连接不同形状的图标（称为VI，Virtual ...
计算器核心算法(一)
热门推荐
小金子的专栏
11-12 1万+
实现了计算器的核心功能,递归算法,带领大家一步一步的实现等式的混合运算
"计算器算法"(含括号匹配,小数点)-之高效,通俗易懂详细解析.
农展飞的博客
06-10 1万+
涉及到的技术点(分两部分): 1.第一阶段,没有括号时的计算 1.用ArrayList容器即可解决 2.简单的正则表达式 3.for和while循环 2.带括号,重点: 1.匹配一个完整的括号就算一个,并再加入结果 2.新的集合中长度的获取***关键 3.真正的长度是:右括号减左
计算器逻辑实现算法（加、减、乘、除）- JS版
qq_34813134的博客
08-30 1507
正常来说，我们看到这个表达式都知道怎么运算，知道运算结果 但计算机不一样，计算机无法识别出这串表达式，它只能识别特定的规则： - 6 * + 3 4 5 前缀表达式 63 4 + 5 * -后缀表达式
JAVA 解析计算器
06-10
综上所述，开发一个Java解析计算器涵盖了多方面的知识，包括编程语言基础、编译器设计原理、数据结构、算法以及用户界面设计。每个方面都需要深入理解和实践才能构建出功能完备且用户友好的计算器应用。
基于Java的计算器算法(源代码).pdf
11-30
本文将详细解析一个基于Java编程语言实现的计算器程序，它具有与Windows附件中标准计算器类似的功能和界面。虽然这个计算器目前不支持键盘操作，但其设计思路和代码结构对于学习Java GUI编程以及计算器算法有着重要...
java 计算器算法
04-23
这通常通过解析算法实现，如简单扫描法或更复杂的词法分析器（lexer）和语法分析器（parser）。 - 在这个例子中，`Calculator.java`可能实现了一个简单的算法，逐字符扫描并解析输入的表达式，识别出数字和运算符。...
数据结构与算法课程设计计算器实现
05-09
在本项目中，“数据结构与算法课程设计计算器实现”是一个基于数据结构和算法的实践项目，目的是帮助学生理解和应用这些核心计算机科学概念。这个计算器的实现主要涉及到了栈这一数据结构，以及相关的算法来处理计算...
计算器算法（支持加减乘除括号）
08-05
NULL 博文链接：https://bo-hai.iteye.com/blog/2049737
简单计算器算法
01-01
基于Android平台的简单计算器，上面的计算器的基本算fa
很好用一个简单的计算器算法做法
07-05
一个比较好的Java写的计算器代码！ /** * 一个计算器，与Windows附件自带计算器的标准版功能、界面相仿。 但还不支持键盘操作。 */ public class Calculator extends JFrame implements ActionListener {
计算器运算逻辑实现（带括号，求余，乘方，加减乘除），不使用eval函数-前端JavaScript 源码实现——括号匹配与初等运算。
qq_51165365的博客
10-25 304
1，实现计算归纳2，整体运算逻辑3，括号匹配与去括号4，数字分割与初等混合运算5，运算符的顺序6，JS源码实现效果展示。
基于c语言的四则运算计算器代码实现方法（提供三种方案）
最新发布
2301_78146269的博客
02-29 2519
该方案最为简单，先放置菜单，供用户选择运算形式，随后读取用户输入的两个操作数，通过switch函数分别进行不同的运算。四则运算之间相对独立，彼此之间并无联系，逻辑简单，易于理解。printf("1.加法 2.减法 3.乘法 4.除法 0.退出游戏");int y = 0;menu();printf("请选择>");case 1:printf("请输入两个操作数>");break;
[离散数学]使用c++写一个逻辑运算计算器
m0_74166068的博客
11-02 960
用c++和visual studio 2022实现一个离散数学真值表的打印，无论输入的命题是否带有括号，都能进行计算。点开看看，说不一定是你需要的呢乁( ˙ ω˙乁)
数据结构与算法：计算器实现（Python）
爱出名的狗腿子
02-19 788
本文主要采用数据结构与算法的知识，采用Python语言，完成计算器的实现。其主要实现思路是： 1. 将人类易于理解的中缀表达式转化为计算机易于理解的后缀表达式； 2. 采用后缀表达式，栈操作实现算式运算
C语言计算器的三种实现方法
qq_74319491的博客
11-21 1270
中我们写的计算机的实现的代码中，红⾊框中的代码是重复出现的，其中虽然执⾏计算的逻辑是区别的，但是输⼊输出操作是冗余的，有没有办法，简化⼀些呢？因为红⾊框中的代码，只有调⽤函数的逻辑是有差异的，我们可以把调⽤的函数的地址以参数的形式传递过去，使⽤函数指针接收，函数指针指向什么函数就调⽤什么函数，这⾥其实使⽤的就是回调函。如果你把函数的指针（地址）作为参数传递给另⼀个函数，当这个指针被⽤来调⽤其所指向的函数时，被调⽤的函数就是回调函数。回调函数就是⼀个通过函数指针调⽤的函数。
计算器算法（多位数，小数点均可）
qq_42429889的博客
04-15 2208
计算器算法（多位数，小数点均可） /** * * 波兰式计算算法类 * */ public class Calculate { private static final Stack<String> operator = new Stack<>() ; //操作符 private static final Stack<String> ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值