QT——计算器核心算法

1.中缀表达式转后缀表达式

(1)分离算法（数字和符号分离）

中缀表达式中包含：数字和小数点、符号位（+或-）、运算符（+-*/）、括号

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

当前字符exp[i]为数字或小数点时：累计num+=exp[i]
当前字符exp[i]为符号时：
- num为运算数，分离并保存
- 若exp[i]为正负号，num+=exp[i]
- 若exp[i]为运算符，分离并保存

难点：如何区分正负号与加号和减号？

+和-在表达式的第一个位置
括号后的+和-
运算符后的+和-

（2）中缀表达式转后缀表达式

后缀表达式没有括号，并且保留中缀表达式中的运算优先级，转换过程为：

当前元素e为数字：输出
当前元素e为运算符
- 与栈顶运算符进行优先级比较
  - 小于等于：将栈顶元素输出，然后再与栈顶运算符进行优先级比较
  - 大于：将当前元素e入栈
当前元素e为左括号：入栈
当前元素e为右括号
- 弹出栈顶元素并输出，直至栈顶元素为左括号
- 将栈顶的左括号从栈中弹出

关键点：转化过程中，如何确保表达式中的括号能够左右匹配？------借助栈

（3）根据后缀表达式计算结果

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

当前元素为数字：进栈
当前元素为运算符：
- 从栈中弹出右操作数
- 从栈中弹出坐操作数
- 根据符号进行运算
- 将运算结果压入栈中

遍历结束，栈中唯一数字为运算结果

QCalculatorDec.h

复制代码

#ifndef QCALCULATORDEC_H
#define QCALCULATORDEC_H
#include <QString>
#include <QChar>
#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);
    QQueue<QString> split(const QString& exp); //分离算法,<QString> 就是给这个空盒子贴标签：这个队列只能存放 QString 类型的字符串。
    bool match(QQueue<QString>& exp); //括号匹配算法
    bool transform(QQueue<QString>& exp, QQueue<QString>& output);
    QString calculate(QQueue<QString>& exp); //计算结果
    QString calculate(QString l, QString op, QString r);
public:
    QCalculatorDec();
    ~QCalculatorDec();
    bool expression(const QString& exp);
    QString expression();
    QString result();
};

#endif // QCALCULATORDEC_H

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::expression()
{

}
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插入队列当中
                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;
}
bool QCalculatorDec::transform(QQueue<QString>& exp, QQueue<QString>& output)
{
    bool ret = true;
    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;
}