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

最新推荐文章于 2024-11-09 14:41:27 发布
最新推荐文章于 2024-11-09 14:41:27 发布
阅读量85 收藏
点赞数
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44550629/article/details/128711332
版权

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

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

转换过程：——当前元素e为数字：输出——当前元素e为运算符：1.与栈顶运算符进行优先级比较2.小于等于：将栈顶元素输出，转13.大于：将当前元素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;
}
程咬金爱编程
关注
万能计算器——中缀表达式转换成后缀表达式（C++实现）【可以计算小数和负数】
m0_37546257的博客
05-10 1346
核心代码与思路： int GetExprValue(vector<string> srcVec) //根据后缀表达式求值 { stack<int> temp; char op = '\0'; int a = 0; int b = 0; for (int i = 0; i < srcVec.size(); i++) { op = srcVec[i][srcVec[i].length() - 1]; if (isdigit(op)) { temp.pus
计算器(中缀表达式转后缀表达式）
albertluf的博客
01-23 1036
问题 G: 计算(calc) 时间限制: 1 Sec  内存限制: 128 MB 提交: 8  解决: 3 [提交][状态][讨论版] 题目描述 小明在你的帮助下，破密了Ferrari设的密码门，正要往前走，突然又出现了一个密码门，门上有一个算式，其中只有“(”，“)”，“0-9”，“+”，“-”，“*”，“/”，“^”，求出的值就是密码。小明数学学得不好，还需你帮他的忙。(“/
计算器思想-中缀表达式转化为后缀表达式
m0_56332287的博客
10-31 86
4.4进入集合，-进入栈，与此时的栈顶元素比较，此时栈顶元素是左括号，-直接放入栈中 集合3 4 栈 - （ -8.*进栈，优先等于栈顶元素，弹出栈顶元素，10进入集合 集合 3 4 3 - 5 / 10 栈 - *5.3进入集合，-和栈顶元素比较，优先级相等或者小于，将栈顶元素-弹出 集合中为 3 4 3 - 栈-（但是计算机的思维是线性的，计算机会按照算式的前后顺序，从前往后进行运算，这样会导致运算结果错误。7./进栈，优先级大于-，直接进栈，5 进入集合 集合3 4 3 - 5 栈- /
简单计算器-中缀表达式转后缀表达式
blastospore的博客
12-22 1370
只允许一位数的运算，确实是“简单”计算器 文章目录一、算法思想二、代码总结 # 题目描述： 实现一个简单的计算器，输入一个包含圆括号、加减乘除、求余等符号组成的算术表达式字符串，输出该算术表达式的值。要求： （1）系统至少能实现加、减、乘、除、求余等运算； （2）利用栈实现并将表达式结果输出。 一、算法思想 模仿计算器的思想，对输入的中缀表达式转化为后缀表达式在计算。 在转化的时候使用一个栈用于存储操作符。 在使用后缀表达式计算的时候使用一个栈用来存储数字 二、代码 #include<bits/s
顺序栈计算器 中缀转后缀表达式
weixin_60344133的博客
10-29 1689
《数据结构（用面向对象方法与c++语言描述）第2版》书中虽有介绍计算后缀表达式的方法和中缀转后缀的方法，但这两个函数却是分离的，并未介绍输入一个中缀表达式，由类内部自动转化为后缀表达式并运算的方法。本篇简略介绍后缀表达式运算及实现上述流程。
栈实现计算器 中缀表达式转后缀表达式
星云
06-01 283
逻辑 实现计算器只需要一个栈。数值直接进入后缀表达式。运算符是否进入栈取决于其优先级是否大于栈顶运算符的优先级，如果大于则入栈，否则栈顶运算符出栈，重复比较直至其能入栈为止。 计算时，后缀表达式的数值直接入栈。遇到运算符时每次从后缀表达式中取出一到两个数值参与运算，运算结果直接入栈。若后缀表达式扫描完毕后栈中仅存在一个数值，则这个值就是表达式的计算结果。 ????C语言实现计算器代码点此 运行截图 代码 #!/usr/bin/env python # -*- coding: utf-8 -*- ''' 表
第一个Android实例——计算器
化身孤岛的瓜
09-22 470
学习Android已经有一段时间了，最近一直在啃书，感觉挺充实的~好期待放假，这样可以快点把书看完自己去多做点实例项目，加深理解。 这是之前写的一个计算器小程序，比较简单，但是是自己第一个用Android写出来的小程序，值得纪念噢~ 计算器实例 第一部分：计算器布局设计        首选需要new一个Android项目，然后修改界面布局，代码如下   &lt;LinearLayo...
用java将中缀表达式转换成后缀表达式（逆波兰表达式）实现功能简单的计算器
HXZ_CREATE的博客
09-07 830
文章目录中缀表达式转成后缀表达式：通过后缀表达式来计算结果：代码实现：将中缀表达式存入LIst：将中缀表达式的List转换成逆波兰表达式的List：完成对逆波兰表达式的计算：定义一个类，可以返回运算符的优先顺序：测试代码： 中缀表达式：就是常见的运算表达式：如"3+52","4-(23)+9" 后缀表达式（逆波兰表达式）：不包含括号，运算符放在两个运算对象的后面，所有的计算按运算符出现的顺序，严格从左向右进行（不再考虑运算符的优先规则）。      &nb
计算器，计算后缀表达式，转中缀表达式为后缀表达式
01-10
一个算术表达式是由操作数(operand)、运算符(operator)和括号组成的。假设操作数均是正实数，运算符只含加减乘除四种运算符。编程利用“算符优先法”求算术表达式的值。用户可选择需要进行的操纵，包括后缀表达式的计算，中缀表达式转为后缀表达式，清屏和退出，界面清晰，操作简便，且有足够的输入合法性检验
Android Studio开发的简易版计算器，将中缀表达式转为后缀表达式后进行计算
07-09
这是用Android studio开发的一款简易计算器，主要思路是先对计算式进行提取，再将中缀表达式转为后缀表达式进行计算。可以下载学习，或者应用于Android大作业及课程设计，在代码包的calculator4\build\outputs\apk\...
C++实现中缀表达式转后缀表达式
12-20
将中缀表达式转换为后缀表达式主要涉及以下步骤： 1. 使用字符数组存储整个输入的中缀表达式。 2. 从数组的第一个字符开始遍历，若字符是数字，则连续读取直至构成一个整数，并直接输出这个整数。 3. 如果遇到左...
中缀表达式转后缀表达式并求值（实现多位操作数读取运算，包含具体Java代码）
JellyfishMIX 的博客
10-22 1026
提出问题 上周数据结构实验课要求写一个中缀式转后缀式，并计算后缀式的值。成熟思路网上有很多，这里不再造轮子讲一遍了。 例如这篇：https://blog.csdn.net/Ring_k/article/details/79598961，这篇文章的举例部分，把中缀式转后缀式的过程一步步写了出来，显示了操作数读取、操作符栈、输出的状态，作者很细心，博主就是参考的这篇文章介绍的原理，感谢作者的原理讲...
中缀表达式计算中栈内优先级、栈外优先级的排序原理
热门推荐
qq_43432875的博客
10-12 1万+
前言： 有关中缀表达式计算是数据结构中非常经典的题目，以至于很多文章或课本喜欢直接给出计算方法一步到位，但关于其中的原理却并未深究，本文试图通过分析运算符的栈内优先级，栈外优先级的排序方法探求中缀表达式计算中的原理。为了简便起见，在本文的讨论中只考虑双目运算符（仅＋、－、＊、/　四种）以及括号。并默认输入的表达式正确。 引用： 请看完这篇文章以对中缀表达式的计算有一个大体...
计算器：中缀转后缀与后缀的计算
研究邪术！
09-16 611
分别写了中缀转后缀，用后缀进行计算的两个源文件，后来想着干脆把它们连起来做个计算器吧。两个栈的声明完全可以合成一个类模板，不过既然复制粘贴很方便，就没去修改。而且这样一个是数组栈，而另一个是链表栈，也挺好的。 写中缀转换栈的函数时遇到了些问题，主要是在左括号的处理上。不妨写几个中缀表达式做测试，这样可以更好地理解原理。 简单来说，两个模块可以归成以下的思路。（参考了洛谷的题解） #include<iostream> #include<string> #define MAX_N 10
计算器：中缀表达式转后缀表达式
给永远比拿愉快
02-10 3563
这几天想写一个Android的计算器，所以先写好中缀表达式到后缀表达式的计算。 例如：中缀表达式(8+9*10)-4/2+3 我们可以进行如下操作： 1、将每个操作符对应的两个操作数用括号括上(((8+(9*10))-(4/2))+3) 2、将操作符移到对应的括号外(((8(910*)+)(42)/)-3)+ 3、去掉括号即可  8910*+42/-3+ 那么计算机中是怎样进行的呢
中缀转后缀并求值(简单计算器的核心)
zycxnanwang的博客
09-19 2110
中缀转后缀并求值做一个简单的计算器，关键的技术就是表达式求值 #### 将中缀表达式转化为后缀表达式 string s 为原始表达式， stack S作为操作符栈， vector V存储后缀表达式结果 如果是操作字符，分一下几种情况 (优先级说明：乘除的优先级，高于加减；’)’的优先级最低，‘(’的优先级最高) 如果字符栈为空，直接将操作符入栈 S 如果栈顶
【数据结构与算法 7】中缀表达式转为后缀表达式
2401_84047990的博客
04-05 431
小编也是很有感触，如果一直都是在中小公司，没有接触过大型的互联网架构设计的话，只靠自己看书去提升可能一辈子都很难达到高级架构师的技术和认知高度。向厉害的人去学习是最有效减少时间摸索、精力浪费的方式。我们选择的这个行业就一直要持续的学习，又很吃青春饭。虽然大家可能经常见到说程序员年薪几十万，但这样的人毕竟不是大部份，要么是有名校光环，要么是在阿里华为这样的大企业。年龄一大，更有可能被裁。送给每一位想学习Java小伙伴，用来提升自己。
判断是否是Symbol类型
Wangdanting123的博客
06-23 2049
/** * 判断`value`是否是`Symbol`类型 * Checks if `value` is classified as a `Symbol` primitive or Object. * * @param {*} value The value to check. * @returns {boolean} Returns `true` if `value` is a sym...
C 语言冒泡排序算法详解
最新发布
licy__的博客
11-09 159
冒泡排序是一种简单的排序算法，它通过重复地遍历要排序的列表，比较相邻的元素并根据需要交换它们的位置来实现排序。尽管冒泡排序的时间复杂度较高（O(n²)），但它因其简单易懂而常用于教学目的。本文将详细介绍冒泡排序的工作原理，并提供一个用 C 语言实现的示例。冒泡排序的基本思想是通过多次遍历待排序的列表，每次遍历时比较相邻的两个元素，如果前一个元素大于后一个元素，则交换它们的位置。这样，每遍历一次，最大的元素就会像气泡一样“浮”到列表的末尾。这个过程会重复进行，直到整个列表变得有序。
python - leetcode【数据结构-算法】-入门/通关手册
weixin_44151034的博客
11-05 1035
因为笔者马上要去面试了，正在刷leetcode，同时准备着与leetcode相关的python知识点。所以其实主要就是介绍上面两个和python相关的算法帖子。Python学习笔记【Python 和 LeetCode 】Python 基础｜LeetCode 算法知识点总结 ｜ 刷LeetCode笔记 ｜ 整理中。。。LeetCode刷题必知的Python知识Python 必知必会知识点python基础语法——常量、变量、注释、输入输出和运算符python教程。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值