QT 学习(十) -- QT计算器核心算法

中缀表达式与后缀表达式
中缀表达式符合人类的阅读和思维习惯
后缀表达式符合计算机的运算方式
后缀表达式的优点：
(1)消除了中缀表达式中的括号
(2)同时保留了中缀表达式中的运算优先级
举例：
1 + 2 --> 1 2 +
1 + 2 * 3 --> 1 2 3 * +
1 + (2 - 1) * 3 --> 1 2 1 - 3 * +

解决方案：

• 将中缀表达式进行数字和运算符的分离
• 将中缀表达式转换为后缀表达式
• 通过后缀表达式计算最终结果

A. 将中缀表达式进行数字和运算符的分离思想：
以符号作为标志，对表达式中的字符逐个访问
(1) 定义累计变量num
(2) 当前字符exp[i]为数字或者小数点时：
累计 num += exp[i]
(3) 当前字符exp[i]为符号时：
num为运算数，分离并保存，并将num清空
若exp[i]为正负号：
累计符号位 + 和 -：num += exp[i]
若exp[i]为运算符:
分离并保存
(4) 将最后一个num保存

伪代码：

头文件：
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); //定义运算符号的优先级
    QQueue<QString> split(const QString& exp);  //分离算法
public:
    QCalculatorDec();
    ~QCalculatorDec();
    bool expression(const QString& exp);
    QString expression();
    QString result();
};
#endif

QCalculatorDec.cpp

#include "QCalculatorDec.h"

#include <QDebug>

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

    QQueue<QString> r = split("+9.11 + ( -3 - 1 ) * -5 ");

    for(int i=0; i<r.length(); i++)
    {
        qDebug() << r[i];
    }
}

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;

    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;
}

B.将中缀表达式转换为后缀表达式思想
整个过程类似于编译过程
(1)四则运算表达式中的括号必须匹配
(2)根据运算符优先级进行运算
(3)转换后的表达式中没有括号
(4)转换后可以顺序计算出最终结果

转换过程：
1.当前元素e为数字：
输出
2.当前元素e为运算符：
与栈顶运算符进行优先级比较
1)小于等于：将栈顶元素输出，转1
2)大于：将当前元素e入栈
3.当前元素e为左括号：
入栈
4.当前元素e为右括号：
1)弹出栈顶元素并输出，直至栈顶元素为左括号
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();
}

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;
}

C：通过后缀表达式计算最终结果
遍历后缀表达式中的数字和运算符
1.当前元素为数字：
进栈
2.当前元素为运算符：
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;
}