计算器核心算法——中缀表达式转为后缀表达式

中缀表达式转后缀表达式的过程类似编译过程
——四则运算表达式中的括号必须匹配
——根据运算符优先级进行转换
——转换后的表达式中没有括号
——转换后可以顺序的计算出最终结果

这是某位伟人研究出的算法，在这里我们直接拿来用就可以。

转换过程：
——当前元素e为数字：输出
——当前元素e为运算符：
1.与栈顶运算符进行优先级比较
2.小于等于：将栈顶元素输出，转1
3.大于：将当前元素e入栈

——当前元素e为左括号：入栈
——当前元素e为右括号：
1.弹出栈顶元素并输出，直至栈顶元素为左括号
2.将栈顶的左括号从栈中弹出

while( !exp.isEmpty() )
{
    QString s = exp.dequeue();
    
    if(isNumber(e))
        输出e;
    else if(isOperator(e))
    {
        while( priority(e) <= priority(stack.top() ))
            输出栈顶元素： stack.pop();
            
        stack.push(e);
    }
    else if(isLeft(e))
        stack.push(e);
    else if(isRight(e))
    {
        while( !isLeft(stack.top() ))
            输出栈顶元素 stack.pop();
            
        从栈中弹出左括号: stack.pop();
    }
}

exp是上篇博客中用分离算法得到的队列了，将里面的每个元算都处理，也就是说一直处理到这个队列为空为止。

关键点：转换过程中左右括号是重要标志
——如何确保表达式中的括号能够左右匹配？

匹配算法实现：

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

for(int i=0; i<len; i++)
{
    if(exp[i]为左括号)
        exp[i]入栈；
    else if(exp[i]为右括号)
    {
        if(栈顶元素为左括号)
            将栈顶元素弹出；
        else    
            匹配错误
    }
}

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

    qDebug() << match(r);
}

QCalculatorDec::~QCalculatorDec()
{

}

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

bool QCalculatorDec::isSymbol(QChar c)   //判读当前的字符C究竟是不是操作符或者括号
{
    return isOperator(c) || (c == '(') || (c == ')');
}

bool QCalculatorDec::isSign(QChar c)  //判断当前的字符是不是正负号
{
    return (c == '+') || (c == '-');
}

bool QCalculatorDec::isNumber(QString s)  //判断当前的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就应该清空，以便累计下一个运算数。

                num.clear();
            }

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

            pre = exp[i];//将这个字符保存下来，当进行下一次循环时，它将作为前一个字符使用
        }
    }

    if(!num.isEmpty())  //如果for循环运行结束之后，num变量里面还有没有东西呢？如果不为空，里面还保存着最后的一个运算数。应将其分离保存到返回队列中去。
    {
        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;
            }
        }
    }

    if( !stack.isEmpty()) //因为在上面的程序中遇到一个右括号就会将左括号弹出栈，如果左右括号完全匹配的话，最后栈中是没有括号的，即为空。
    {                     //就是为了处理"-9.11+ (3 - (-1)* -5" 左括号比右括号多的问题。
        ret = false;
    }

    return ret;
}

 中缀转后缀算法：

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

    QQueue<QString> output;

    transform(r,output);

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

}

QCalculatorDec::~QCalculatorDec()
{

}

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

bool QCalculatorDec::isSymbol(QChar c)   //判读当前的字符C究竟是不是操作符或者括号
{
    return isOperator(c) || (c == '(') || (c == ')');
}

bool QCalculatorDec::isSign(QChar c)  //判断当前的字符是不是正负号
{
    return (c == '+') || (c == '-');
}

bool QCalculatorDec::isNumber(QString s)  //判断当前的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就应该清空，以便累计下一个运算数。

                num.clear();
            }

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

            pre = exp[i];//将这个字符保存下来，当进行下一次循环时，它将作为前一个字符使用
        }
    }

    if(!num.isEmpty())  //如果for循环运行结束之后，num变量里面还有没有东西呢？如果不为空，里面还保存着最后的一个运算数。应将其分离保存到返回队列中去。
    {
        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;
            }
        }
    }

    if( !stack.isEmpty()) //因为在上面的程序中遇到一个右括号就会将左括号弹出栈，如果左右括号完全匹配的话，最后栈中是没有括号的，即为空。
    {                     //就是为了处理"-9.11+ (3 - (-1)* -5" 左括号比右括号多的问题。
        ret = false;
    }

    return ret;
}
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.top());
            }

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