中缀后缀表达式求值--栈的应用

原创 已于 2023-01-20 23:05:19 修改 · 658 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #数据结构

于 2023-01-20 15:51:30 首次发布

前言

本文目的是记录学习过程，理论部分来自其他博主的转载，代码是自己实现，使用了STL的头文件。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<stack>
#include <vector>
using namespace std;

一、中缀表达式转后缀表达式

初始化一个栈，用于保存暂时还不能确定运算顺序的运算符。从左到右处理各个元素，直到末尾。可能遇到三种情况:

遇到操作数: 直接加入后缀表达式。
遇到界限符: 遇到 ‘(’ 直接入栈; 遇到 ‘)’ 则依次弹出栈内运算符并加入后缀表达式，直到弹出 ‘(’ 为止。注意: '(' 不加入后缀表达式。
遇到运算符: 依次弹出栈中优先级高于或等于当前运算符的所有运算符，并加入后缀表达式，若碰到 ‘(’ 或栈空则停止。之后再把当前运算符入栈。
按上述方法处理完所有字符后，将栈中剩余运算符依次弹出，并加入后缀表达式。
————————————————
版权声明：本文为CSDN博主「胖胖的懒羊羊」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_44867340/article/details/119455799

stack<int>jishuan;
    vector<char>bolan;
    string s="1+(9-1)*2/1+5";
    stack<char>yunshuanfu;
    for(int i=0; i<s.size(); i++)
    {
        switch(s[i])
        {
        case '(':
            yunshuanfu.push(s[i]);
            break;
        case ')':
            while(1)
            {
                if(yunshuanfu.top()=='(')
                {
                    yunshuanfu.pop();
                    break;
                }
                else
                {
                    bolan.push_back(yunshuanfu.top());
                    yunshuanfu.pop();
                }
            }
            break;
        case '+': bolan.push_back('#');
            while(!yunshuanfu.empty())
            {
                if(yunshuanfu.top()=='(')
                    break;
                else
                {
                    bolan.push_back(yunshuanfu.top());
                    yunshuanfu.pop();

                }

            }
            yunshuanfu.push(s[i]);
            break;
        case'-': bolan.push_back('#');
            while(!yunshuanfu.empty())
            {
                if(yunshuanfu.top()=='(')
                    break;
                else
                {
                    bolan.push_back(yunshuanfu.top());
                    yunshuanfu.pop();

                }

            }
            yunshuanfu.push(s[i]);
            break;
        case'*': bolan.push_back('#');
            while(!yunshuanfu.empty())
            {
                if(yunshuanfu.top()=='('||yunshuanfu.top()=='+'||yunshuanfu.top()=='-')
                    break;
                else
                {
                    bolan.push_back(yunshuanfu.top());
                    yunshuanfu.pop();
                }


            }
            yunshuanfu.push(s[i]);
            break;
        case'/': bolan.push_back('#');
            while(!yunshuanfu.empty())
            {
                if(yunshuanfu.top()=='('||yunshuanfu.top()=='+'||yunshuanfu.top()=='-')
                    break;
                else
                {
                    bolan.push_back(yunshuanfu.top());
                    yunshuanfu.pop();
                }


            }
            yunshuanfu.push(s[i]);
            break;
        default:
            bolan.push_back(s[i]);
        }

    }

    while(!yunshuanfu.empty())
    {
        bolan.push_back(yunshuanfu.top());
        yunshuanfu.pop();
    }

二、后缀表达式计算

用栈实现后缀表达式的计算（栈用来存放当前暂时不能确定运算次序的操作数）

步骤1: 从左往后扫描下一个元素，直到处理完所有元素;

步骤2: 若扫描到操作数，则压入栈，并回到步骤1;否则执行步骤3;

步骤3: 若扫描到运算符，则弹出两个栈顶元素，执行相应的运算，运算结果压回栈顶，回到步骤1;

注意: 先出栈的是“右操作数”
————————————————
版权声明：本文为CSDN博主「胖胖的懒羊羊」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_44867340/article/details/119455799

代码如下（示例）：

//--------下面是后缀表达式的求解过程-------
   int z,y;//z代表计算左值，y代表计算右值
    for(int j=0; j<bolan.size(); j++)
    {
        if(bolan[j]>='0'&&bolan[j]<='9')
        {
            int x=(bolan[j]-'0');
            while(bolan[j+1]>='0'&&bolan[j+1]<='9')
            { j++;
                x=x*10+(bolan[j]-'0');

            }
            jishuan.push(x);
        }
        else{
       switch(bolan[j])
            {
        case '+':
            y=jishuan.top();
            jishuan.pop();
            z=jishuan.top();
            jishuan.pop();
            jishuan.push(z+y);
            break;
        case '-':
            y=jishuan.top();
            jishuan.pop();
            z=jishuan.top();
            jishuan.pop();
            jishuan.push(z-y);
            break;
        case'*':
             y=jishuan.top();
            jishuan.pop();
            z=jishuan.top();
            jishuan.pop();
            jishuan.push(z*y);
            break;
        case'/':
             y=jishuan.top();
            jishuan.pop();
            z=jishuan.top();
            jishuan.pop();
            jishuan.push(z/y);
            break;
            }



        }
    }

三、总体代码

代码如下（示例）：


#include<iostream>
#include<cstdio>
#include<cstring>
#include<stack>
#include <vector>
using namespace std;
int main()
{
    stack<int>jishuan;
    vector<char>bolan;
    string s="1+(9-1)*2/1+5";
    stack<char>yunshuanfu;
    for(int i=0; i<s.size(); i++)
    {
        switch(s[i])
        {
        case '(':
            yunshuanfu.push(s[i]);
            break;
        case ')':
            while(1)
            {
                if(yunshuanfu.top()=='(')
                {
                    yunshuanfu.pop();
                    break;
                }
                else
                {
                    bolan.push_back(yunshuanfu.top());
                    yunshuanfu.pop();
                }
            }
            break;
        case '+': bolan.push_back('#');//在两个相邻数字之间创造空格，起区分作用
            while(!yunshuanfu.empty())
            {
                if(yunshuanfu.top()=='(')
                    break;
                else
                {
                    bolan.push_back(yunshuanfu.top());
                    yunshuanfu.pop();

                }

            }
            yunshuanfu.push(s[i]);
            break;
        case'-': bolan.push_back('#');
            while(!yunshuanfu.empty())
            {
                if(yunshuanfu.top()=='(')
                    break;
                else
                {
                    bolan.push_back(yunshuanfu.top());
                    yunshuanfu.pop();

                }

            }
            yunshuanfu.push(s[i]);
            break;
        case'*': bolan.push_back('#');
            while(!yunshuanfu.empty())
            {
                if(yunshuanfu.top()=='('||yunshuanfu.top()=='+'||yunshuanfu.top()=='-')
                    break;
                else
                {
                    bolan.push_back(yunshuanfu.top());
                    yunshuanfu.pop();
                }


            }
            yunshuanfu.push(s[i]);
            break;
        case'/': bolan.push_back('#');
            while(!yunshuanfu.empty())
            {
                if(yunshuanfu.top()=='('||yunshuanfu.top()=='+'||yunshuanfu.top()=='-')
                    break;
                else
                {
                    bolan.push_back(yunshuanfu.top());
                    yunshuanfu.pop();
                }


            }
            yunshuanfu.push(s[i]);
            break;
        default:
            bolan.push_back(s[i]);
        }

    }

    while(!yunshuanfu.empty())
    {
        bolan.push_back(yunshuanfu.top());
        yunshuanfu.pop();
    }
//--------下面是后缀表达式的求解过程-------
   int z,y;//z代表计算左值，y代表计算右值
    for(int j=0; j<bolan.size(); j++)
    {
        if(bolan[j]>='0'&&bolan[j]<='9')
        {
            int x=(bolan[j]-'0');//-'0'是字符数字转整型数字的方法
            while(bolan[j+1]>='0'&&bolan[j+1]<='9')
            { j++;
                x=x*10+(bolan[j]-'0');

            }
            jishuan.push(x);
        }
        else{
       switch(bolan[j])
            {
        case '+':
            y=jishuan.top();
            jishuan.pop();
            z=jishuan.top();
            jishuan.pop();
            jishuan.push(z+y);
            break;
        case '-':
            y=jishuan.top();
            jishuan.pop();
            z=jishuan.top();
            jishuan.pop();
            jishuan.push(z-y);
            break;
        case'*':
             y=jishuan.top();
            jishuan.pop();
            z=jishuan.top();
            jishuan.pop();
            jishuan.push(z*y);
            break;
        case'/':
             y=jishuan.top();
            jishuan.pop();
            z=jishuan.top();
            jishuan.pop();
            jishuan.push(z/y);
            break;
            }



        }
    }

cout<<"计算结果是"<<":"<<jishuan.top()<<endl;

}

总结

主要考察栈的基本操作和字符的读取转换，如有问题请指正。

【数据结构】-栈--中缀表达式转后缀表达式-表达式求值
vector的博客
06-08 1493
typedef struct mystk { char stack[10]; int top = -1; }mystk;//中缀转后缀时放操作符的栈 typedef struct hisstk { int stack[10]; int top = -1; }hisstk;//后缀求值时放临时计算结果的栈 int priority(char a) {//操作符优先级 switch (a) { case '+': case '-': return 1; case '*': ...
用栈实现中缀表达式求值
热门推荐
qq_63128704的博客
10-02 1万+
在中缀表达式求值的具体实现中，我们定义了两个栈，分别是StackNum和StackChar，他们分别用来存储运算数和运算符，利用栈后进先出的特点进行计算。在构造的过程中，为了使代码更简洁可读，借助了C语言中的数组，本质上是运用了栈的顺序实现。使用运算数栈和运算符栈这两个栈实现中缀向后缀的转化并完成计算。 为了实现模块化编程，增加代码可读性，我们定义了一些函数。其中InitNum和InitChar分别用于运算数栈和运算符栈初始化，PushNum和PushChar分别用于将运算数压入栈和运算符压入栈，PopN
中缀表达式的求值（栈实现）
08-05
模拟计算器的功能，对输入的一串表达式进行求值。算法定义了运算符的优先级，最后利用栈的方法来实现。
中缀表达式求值（栈的应用）
solego’s blog
03-14 965
题目： 表达式求值 题意： 给定一个长度不超过10510^5105的表达式，请你求出这个表达式的值。 保证数字计算过程中直接得到的数字不会为负数，且只有+,-,*,/,(,)这666种字符。 数据范围：∣s∣≤105|s| \leq 10^5∣s∣≤105 题解： 这里将加减称为add，乘除称为mul。 因为减法可以转换为一个数加上一个负数，除法的分母模意义下可以转换为逆元。 考虑我们通常对一个不带括号的中缀表达式进行求值，大概如下四种情况： 前add后add：a+b+d，那么我们可以先计算得到a+b=c
用栈计算中缀表达式（具体详细，还包含getchar的用法）
zhang050118的博客
05-05 666
答：当返回1时有一种情况时读取到的是 ‘)’ ,此时如果还读取一次，运算符栈内的 ‘(’ 就不会出栈，后面的一系列运算就会出问题。（1）如果返回的是-1（就代表栈顶元素优先级低于读取到的字符），我们就把读取到的字符入栈并且再执行一次 ch=getchar()运算符栈出一次栈，运算数字就出两次栈（两次出栈顺序要相反，因为出栈顺序是和入栈顺序相反的），把得到的结果压入运算数字栈内。=‘#’ 时，就代表已经读完了表达式，而此时运算符栈里面可能还有运算符没有做完，就还需要做进行一次运算。
python 表达式求值_用栈进行表达式求值
weixin_39954487的博客
12-03 1176
上一节课，我们介绍了栈，并且在习题里使用栈计算了后缀表达式(最后一道题，这道题一定要先完成。如果那道题做不出来，这节课的内容就更加难以理解)。我们今天继续看一下，如何使用栈完成标准的四则混合运算表达式求值。不同于后缀表达式，遇到一个运算符就可以直接从栈里取两个数进行运算。在标准的四则混合运算表达式中(或者我们称之为中缀表达式)，遇到一个操作符是不能直接计算的，因为计算的顺序要取决于后面的运算符。多...
【栈】中缀表达式求值（简易计算器）
wangwm_的博客
05-01 1155
这里介绍中缀表达式求值的两种方法： （1）、先将中缀表达式转化为后缀表达式，再利用后缀表达式求值算法计算，这里可看之前的文章，中缀表达式转化为后缀表达式和后缀表达式求值； （2）、利用栈来实现，这里需要两个栈：数据栈和操作符栈，依次扫描字符串，遇到数据就压入数据栈中，遇到操作符，则判断其与操作符栈栈顶元素的优先级，这里可参考文章里的判断方法：中缀表达式转化为后缀表达式； 方法（2）的具体代码如下：（代码多位数运算存在bug，暂时没修改，大佬可以评论区修改） #include<bits/std
表达式求值（中缀表达式转为后缀表达式）--数据结构与算法--栈
Liu1_1_的博客
10-19 538
本文利用数据结构中的栈实现了，表达式求值，以及后缀表达式和中缀表达式的转换，希望对读者有所帮助。
【优选算法】栈 {后缀表达式求值；中缀转后缀表达式；中缀表达式求值}
最新发布
52Herzt的博客
06-04 1446
【优选算法】栈 {何时使用栈结构？后缀表达式求值；中缀转后缀表达式；中缀表达式求值}
数据结构实验报告3-栈与队列-中缀表达式求值-实验内容及要求.docx
07-06
算法的核心思想是先将中缀表达式转换为后缀表达式（逆波兰表示法），然后基于后缀表达式进行求值。 1. **中缀转后缀**： - 遍历输入的中缀表达式。 - 遇到操作数时，直接输出。 - 遇到运算符或括号时，根据...
C语言：中缀算术表达式求值（栈 附答案）.docx
10-26
为了实现这个功能，我们需要理解栈的性质以及中缀表达式到后缀表达式的转换方法。 首先，我们要创建两个栈：一个存储操作数（numbers），另一个存储运算符（operators）。栈是一种后进先出（LIFO）的数据结构，非常...
基于栈结构的中缀表达式求值实验报告
05-25
基于栈结构的中缀表达式求值 用c语言详细的叙述了如何求栈结构的中缀表达式的值
数据结构实验2《基于栈的中缀算术表达式求值》
Madelena的博客
10-15 2900
（visual studio 2019可运行） 输入及输出要求见《数据结构C语言(第二版)》严蔚敏版 【本文仅用于啥都看不懂还想交作业选手】 #include <iostream> #include <stdlib.h> #include <cstring> #include<iomanip>//该头文件为了后面的输出保留两位小数 #define MAXSIZE 100//初始分配的存储空间 #define OK 1 #define OVERFLOW -2
利用栈对中缀表达式求值
qq_51871780的博客
02-17 1034
栈的应用：表达式求值
栈实现中缀表达式
Daylight629博客
10-05 652
栈实现中缀表达式 1.创建两个栈，一个用来存储数字一个用来存储操作符号 2.判断每一个字符是数字还是操作符 3.如果是数字，直接存入数栈中 4.如果是符号，看符号栈是否为空，如果为空直接存入 5.如果符号栈不为空，从符号栈中取出一个数据与当前符号比较，如果当前操作符优先级高于栈取出的，直接存入，否则从数栈中弹出两个数据与当前符号进行运算，把得到的结果存入数栈中 6.在判断两位数的时候，我们扫描的时候需要看看下一位是否也是数字，不能拿第一个数字的存入栈中，如果下一位不是数字直接存入，如果下一位是数字接着扫描直
数据结构 堆栈 实现中缀表达式求值
weixin_43153217的博客
08-10 611
堆栈(Stack):具有一定操作约束的线性表，即只在一端(栈顶，Top)做插入，删除。 插入数据：入栈(Push) 删除数据：出栈(Pop) 先入后出原则：Last In First Out 示例图： [外链图片转存失败(img-u4pafezE-1565436777479)(D:/youdao_picture/stack.jpg)] 栈的顺序存储实现： 栈的顺序存储实现通常由一个一维数组和一...
[C语言、C++]数据结构作业：用栈实现中缀表达式直接求值
Yhisken的博客
10-25 668
给定中缀表达式，用2个栈直接求值。
栈的应用-中缀表达式求值
Mind Code
10-16 1067
使用栈来将中zui
【数据结构与算法】stack栈的介绍和实现、使用栈来实现中缀表达式求值
Bulut0907
09-21 922
栈是一个先入后出的有序列表。允许插入(入栈push)和删除(出栈pop)的一端，称为栈顶(Top)，另一端为固定的一端，称为栈底(Bottom)
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值