第14课 计算器核心解析算法（下）

#include "QCalculatordec.h"

#include <QDebug>

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; //非运算符（含括号）优先级最低，为0

    if((s == "+") || (s =="-"))
    {
        ret = 1;
    }else 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])){
            //遇标识符时，表示读到的己经不是数字了，就将num分离并保存起来
            if(!num.isEmpty())
            {
                ret.enqueue(num);//num进队列，保存起来
                num.clear();
            }

            //如果当前这个非数字的标识符是+或-，则进一步判断是正负号，还是运算符
            //当+或-的前一个有效字符为空、左括号或运算符时，这时他们表示正负号。如+9、(-3、5- -3
            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::transform(QQueue<QString>& exp, QQueue<QString>& output)
{
    bool bRet = match(exp);
    QStack<QString> stack;  //利用栈来保存操作符

    output.clear();

    //依次读入各个token
    while (bRet && !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
        {
            bRet = false;
        }
    }

    //将栈中所有剩余的符号弹出
    while (!stack.isEmpty())
    {
        output.enqueue(stack.pop());
    }

    if(!bRet)  //如果转换时出错，清空输出内容
    {
        output.clear();
    }

    return bRet;
}

//判断括号是否匹配
bool QCalculatorDec::match(QQueue<QString>& exp)
{
    bool bRet = 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
            {
                //遇到右括号时，匹配不成功的原因：
                //1.栈己经是空的，表示没有左括号可以匹配了
                //2.当栈顶元素不是左括号
                bRet = false;
                break;
            }
        }
    }

    //只有当栈己经空了，并且所有右括号都找到匹配，才返回匹配成功
    return bRet && stack.isEmpty();
}

//利用栈对后缀表达式求值
QString QCalculatorDec::calculate(QQueue<QString>& exp)
{
    QString ret = "Error";
    QStack<QString> stack; //栈

    while(!exp.isEmpty())
    {
        QString e = exp.dequeue();//当前token

        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  //非法token（即不是数字或运算符）
        {
            break;
        }
    }

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

    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)) //除数不能为0
            {
                ret = "Error";
            }
            else
            {
                ret.sprintf("%f", lp / rp);
            }
        }
        else
        {
            ret = "Error";
        }
    }

    return ret;
}