含多位数的中缀转后缀的python代码

已于 2024-04-12 14:37:22 修改
阅读量340 收藏 2
点赞数 2
分类专栏： 数据结构类 文章标签： python 算法 开发语言
于 2024-04-12 09:43:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ljxwwd/article/details/137666288
版权

本文的代码适用于多位数的中缀转后缀可用于多括号的计算！

但是暂时无法计算除小括号外的其他括号的计算与转换！

        中缀转后缀是一种常见的算法，用于将中缀表达式转换为后缀表达式，也称为逆波兰表达式。后缀表达式更容易计算和理解，因此在计算机科学中经常用于表达算术表达式。

中缀转后缀的一种常见方法是使用栈来实现。具体步骤如下：

  1. 创建一个操作符栈和一个结果列表。
  2. 从左到右扫描中缀表达式的每个元素。
  3. 如果是操作数，则直接加入结果列表。
  4. 如果是操作符，则判断其优先级：
    • 如果操作符的优先级大于栈顶操作符的优先级，直接入栈。
    • 如果操作符的优先级小于等于栈顶操作符的优先级，则将栈顶操作符出栈，加入结果列表，重复此步骤直到栈为空或者栈顶操作符的优先级小于当前操作符的优先级。
  5. 最后将栈中剩余的操作符依次出栈，加入结果列表。

注：本文章可用于计算的计算函数，可自行创造其他的计算函数进行转换与计算。

# 用于测试的计算函数
# 2*(9+6/3-5)+4
# ((12+6)*5+4)*6
# 6*(((12+6)*5+48)*27+90)
# 8/4*9+6*(((12+6)*5+48)*27+90)

 一、中缀转后缀函数的代码

def zhuan_huan(b):
    infix = str(b)  # 转化为字符串
    jk = len(infix)  # 计算中缀的长度
    ii = 0  # 定义一个参数

    stack = []  # 堆栈的空列表
    postfix = []  # 后缀的空列表
    zhan_postfix = []  # 后缀的暂存空列表
    pan_duan = {'+': 1, '-': 1, '*': 2, '/': 2}  # 建立字典
    cd = 0  # 定义一个参数

    for char in infix:  # 从中缀中的第一个字符读取
        if char.isalnum():  # 判断是否包含字母和数字字符，是的话则成立
            cd += 1  # 对cd进行累加
            zhan_postfix.append(char)  # 将char写入暂存列表

        elif char == '(':  # 判断是否为左括号
            stack.append(char)  # 将char写入堆栈的列表
            cd = 0  # 将cd从新定义等于0
        elif char == ')':  # 判断是否为右括号
            while stack[-1] != '(':  # 判断堆栈的最后一个元素是否为左括号
                if cd == int(1):
                    postfix.append(''.join(zhan_postfix))  # 将zhan_postfix列表的元素相加然后写入postfix列表
                    del zhan_postfix[:]  # 清空zhan_postfix列表
                elif cd >= 2:
                    if len(zhan_postfix) != 0:  # 判断zhan_postfix列表长度等不等于0
                        ss = ''.join(zhan_postfix)  # 将zhan_postfix列表的元素相加然后赋予ss
                        del zhan_postfix[:]  # 清空zhan_postfix列表
                        postfix.append(ss)  # 将ss写入postfix列表
                postfix.append(stack.pop())  # 将stack列表的栈顶写入postfix列表
            stack.pop()  # stack列表的栈顶出栈
            cd = 0  # 将cd从新定义等于0
        else:
            while stack and pan_duan.get(stack[-1], 0) >= pan_duan.get(char, 0):  # 判断stack列表的最后一个元素在pan_duan的字典与char在在pan_duan的字典的大小比较
                if cd == int(1):
                    postfix.append(''.join(zhan_postfix))  # 将zhan_postfix列表的元素相加然后写入postfix列表
                    del zhan_postfix[:]  # 清空zhan_postfix列表
                elif cd >= 2:
                    if len(zhan_postfix) != int(0):  # 判断zhan_postfix列表长度等不等于0
                        ss = ''.join(zhan_postfix)  # 将zhan_postfix列表的元素相加然后赋予ss
                        del zhan_postfix[:]  # 清空zhan_postfix列表
                        postfix.append(ss)  # 将ss写入postfix列表
                postfix.append(stack.pop())  # 将stack列表的栈顶写入postfix列表
            if cd == int(1):
                postfix.append(''.join(zhan_postfix))  # 将zhan_postfix列表的元素相加然后写入postfix列表
                del zhan_postfix[:]  # 清空zhan_postfix列表
            elif cd >= 2:
                if len(zhan_postfix) != int(0):  # 判断zhan_postfix列表长度等不等于0
                    ss = ''.join(zhan_postfix)  # 将zhan_postfix列表的元素相加然后赋予ss
                    del zhan_postfix[:]  # 清空zhan_postfix列表
                    postfix.append(ss)  # 将ss写入postfix列表
            stack.append(char)  # 将char写入堆栈的列表
            cd = 0  # 将cd从新定义等于0
    for i in range(jk):
        ii += 1
        if ii == jk:
            ss = ''.join(zhan_postfix)  # 将zhan_postfix列表的元素相加然后赋予ss
            del zhan_postfix[:]  # 清空zhan_postfix列表
            postfix.append(ss)
    while stack:
        postfix.append(stack.pop())

    a = ' '.join(postfix)  # 将zhan_postfix列表的元素相加然后赋予a
    print(a)
    return a  #返回a

二、后缀函数的计算代码 

        在后缀计算时如果存在多位数则输入时最后数与数之间、数与计算符号之间加多一个空格符，因为本文暂时 还无法解决此问题，例如“7189+”这个简单的后缀相加，可以有71+89，可以有7+189等，如果输入的是“718 9 +”，这718与9之间有空格符则电脑容易识别718+9然后进行运算。

def jisuan(a):
    postfix = str(a)  # 转化为字符串

    shu = []  # 定义空列表——>数字的列表
    fuhao = []  # 定义空列表——>计算符号的列表

    for char in postfix.split():
        if char.isdigit():  # 判断是否是数字，是的话则成立
            shu.append(char)  # 将char写入shu列表
        else:
            fuhao.append(char)  # 将char写入fuhao列表
        if len(fuhao) == 1:  # 判断fuhao列表长度是否为1
            a = str(shu.pop())  # 将shu列表的最后一个元素给予a，并转换为str型
            b = str(fuhao.pop())  # 将fuhao列表的最后一个元素给予b，并转换为str型
            c = str(shu.pop())  # 将shu列表的倒数第二个元素给予c，并转换为str型
            han = c + b + a  # 字符合成，形成han函数
            ji_suan = eval(han)  # 运算han函数
            shu.append(ji_suan)  # 将运算后的han函数写入到shu列表
    d = shu.pop()  # 将shu列表的最后一个元素给予d，即将最后计算的结果给予d
    print(d)
    return d  # 返回d

三、创建GUI界面用于方便使用及美化

from tkinter import *  # 导入tkinter库

root = Tk()
root.geometry("300x200+600+300")  # 定义界面的大小位置
root.title("中缀与后缀")  # 给界面起名
root.resizable(False, False)  # 让界面无法放大
root.wm_attributes("-topmost", 1)  # 让界面始终在电脑屏幕表面

def zhuan():
    infix = str(entry.get())
    b = str(zhuan_huan(infix))
    label3.config(text=b)


def zhuan1():
    infix = str(entry.get())
    postfix = str(zhuan_huan(infix))
    x = jisuan(postfix)
    label5.config(text=x)


def jisuan1():
    postfix = str(entry1.get())
    y = jisuan(postfix)
    label8.config(text=y)


entry = Entry(root)
entry.place(x=130, y=25)
entry1 = Entry(root)
entry1.place(x=130, y=100)

label1 = Label(root, text="请输入中缀表达式:", fg='blue')
label1.place(x=20, y=25)
label2 = Label(root, text="后缀表达式:", fg='blue')
label2.place(x=20, y=50)
label3 = Label(root, text="", fg='black')
label3.place(x=130, y=50)
label4 = Label(root, text="后缀计算结果:", fg='blue')
label4.place(x=20, y=75)
label5 = Label(root, text="", fg='black')
label5.place(x=130, y=75)
label6 = Label(root, text="请输入后缀表达式:", fg='blue')
label6.place(x=20, y=100)
label7 = Label(root, text="直接计算后缀结果:", fg='blue')
label7.place(x=20, y=125)
label8 = Label(root, text="", fg='black')
label8.place(x=130, y=125)


button = Button(root, text="开始中缀转后缀", fg='red', command=zhuan)
button.place(x=10, y=150)

button1 = Button(root, text="中缀转后缀计算", fg='red', command=zhuan1)
button1.place(x=110, y=150)

button2 = Button(root, text="后缀直接计算", fg='red', command=jisuan1)
button2.place(x=210, y=150)

root.mainloop()

四、完整代码 

from tkinter import *  # 导入tkinter库

# 用于测试的计算函数
# 2*(9+6/3-5)+4
# ((12+6)*5+4)*6
# 6*(((12+6)*5+48)*27+90)
# 8/4*9+6*(((12+6)*5+48)*27+90)
root = Tk()
root.geometry("300x200+600+300")  # 定义界面的大小位置
root.title("中缀与后缀")  # 给界面起名
root.resizable(False, False)  # 让界面无法放大
root.wm_attributes("-topmost", 1)  # 让界面始终在电脑屏幕表面


def zhuan_huan(b):
    infix = str(b)  # 转化为字符串
    jk = len(infix)  # 计算中缀的长度
    ii = 0  # 定义一个参数

    stack = []  # 堆栈的空列表
    postfix = []  # 后缀的空列表
    zhan_postfix = []  # 后缀的暂存空列表
    pan_duan = {'+': 1, '-': 1, '*': 2, '/': 2}  # 建立字典
    cd = 0  # 定义一个参数

    for char in infix:  # 从中缀中的第一个字符读取
        if char.isalnum():  # 判断是否包含字母和数字字符，是的话则成立
            cd += 1  # 对cd进行累加
            zhan_postfix.append(char)  # 将char写入暂存列表

        elif char == '(':  # 判断是否为左括号
            stack.append(char)  # 将char写入堆栈的列表
            cd = 0  # 将cd从新定义等于0
        elif char == ')':  # 判断是否为右括号
            while stack[-1] != '(':  # 判断堆栈的最后一个元素是否为左括号
                if cd == int(1):
                    postfix.append(''.join(zhan_postfix))  # 将zhan_postfix列表的元素相加然后写入postfix列表
                    del zhan_postfix[:]  # 清空zhan_postfix列表
                elif cd >= 2:
                    if len(zhan_postfix) != 0:  # 判断zhan_postfix列表长度等不等于0
                        ss = ''.join(zhan_postfix)  # 将zhan_postfix列表的元素相加然后赋予ss
                        del zhan_postfix[:]  # 清空zhan_postfix列表
                        postfix.append(ss)  # 将ss写入postfix列表
                postfix.append(stack.pop())  # 将stack列表的栈顶写入postfix列表
            stack.pop()  # stack列表的栈顶出栈
            cd = 0  # 将cd从新定义等于0
        else:
            while stack and pan_duan.get(stack[-1], 0) >= pan_duan.get(char, 0):  # 判断stack列表的最后一个元素在pan_duan的字典与char在在pan_duan的字典的大小比较
                if cd == int(1):
                    postfix.append(''.join(zhan_postfix))  # 将zhan_postfix列表的元素相加然后写入postfix列表
                    del zhan_postfix[:]  # 清空zhan_postfix列表
                elif cd >= 2:
                    if len(zhan_postfix) != int(0):  # 判断zhan_postfix列表长度等不等于0
                        ss = ''.join(zhan_postfix)  # 将zhan_postfix列表的元素相加然后赋予ss
                        del zhan_postfix[:]  # 清空zhan_postfix列表
                        postfix.append(ss)  # 将ss写入postfix列表
                postfix.append(stack.pop())  # 将stack列表的栈顶写入postfix列表
            if cd == int(1):
                postfix.append(''.join(zhan_postfix))  # 将zhan_postfix列表的元素相加然后写入postfix列表
                del zhan_postfix[:]  # 清空zhan_postfix列表
            elif cd >= 2:
                if len(zhan_postfix) != int(0):  # 判断zhan_postfix列表长度等不等于0
                    ss = ''.join(zhan_postfix)  # 将zhan_postfix列表的元素相加然后赋予ss
                    del zhan_postfix[:]  # 清空zhan_postfix列表
                    postfix.append(ss)  # 将ss写入postfix列表
            stack.append(char)  # 将char写入堆栈的列表
            cd = 0  # 将cd从新定义等于0
    for i in range(jk):
        ii += 1
        if ii == jk:
            ss = ''.join(zhan_postfix)  # 将zhan_postfix列表的元素相加然后赋予ss
            del zhan_postfix[:]  # 清空zhan_postfix列表
            postfix.append(ss)
    while stack:
        postfix.append(stack.pop())

    a = ' '.join(postfix)  # 将zhan_postfix列表的元素相加然后赋予a
    print(a)
    return a  #返回a


def jisuan(a):
    postfix = str(a)  # 转化为字符串

    shu = []  # 定义空列表——>数字的列表
    fuhao = []  # 定义空列表——>计算符号的列表

    for char in postfix.split():
        if char.isdigit():  # 判断是否是数字，是的话则成立
            shu.append(char)  # 将char写入shu列表
        else:
            fuhao.append(char)  # 将char写入fuhao列表
        if len(fuhao) == 1:  # 判断fuhao列表长度是否为1
            a = str(shu.pop())  # 将shu列表的最后一个元素给予a，并转换为str型
            b = str(fuhao.pop())  # 将fuhao列表的最后一个元素给予b，并转换为str型
            c = str(shu.pop())  # 将shu列表的倒数第二个元素给予c，并转换为str型
            han = c + b + a  # 字符合成，形成han函数
            ji_suan = eval(han)  # 运算han函数
            shu.append(ji_suan)  # 将运算后的han函数写入到shu列表
    d = shu.pop()  # 将shu列表的最后一个元素给予d，即将最后计算的结果给予d
    print(d)
    return d  # 返回d


def zhuan():
    infix = str(entry.get())
    b = str(zhuan_huan(infix))
    label3.config(text=b)


def zhuan1():
    infix = str(entry.get())
    postfix = str(zhuan_huan(infix))
    x = jisuan(postfix)
    label5.config(text=x)


def jisuan1():
    postfix = str(entry1.get())
    y = jisuan(postfix)
    label8.config(text=y)


entry = Entry(root)
entry.place(x=130, y=25)
entry1 = Entry(root)
entry1.place(x=130, y=100)

label1 = Label(root, text="请输入中缀表达式:", fg='blue')
label1.place(x=20, y=25)
label2 = Label(root, text="后缀表达式:", fg='blue')
label2.place(x=20, y=50)
label3 = Label(root, text="", fg='black')
label3.place(x=130, y=50)
label4 = Label(root, text="后缀计算结果:", fg='blue')
label4.place(x=20, y=75)
label5 = Label(root, text="", fg='black')
label5.place(x=130, y=75)
label6 = Label(root, text="请输入后缀表达式:", fg='blue')
label6.place(x=20, y=100)
label7 = Label(root, text="直接计算后缀结果:", fg='blue')
label7.place(x=20, y=125)
label8 = Label(root, text="", fg='black')
label8.place(x=130, y=125)


button = Button(root, text="开始中缀转后缀", fg='red', command=zhuan)
button.place(x=10, y=150)

button1 = Button(root, text="中缀转后缀计算", fg='red', command=zhuan1)
button1.place(x=110, y=150)

button2 = Button(root, text="后缀直接计算", fg='red', command=jisuan1)
button2.place(x=210, y=150)

root.mainloop()

希望本文章能帮助到你们，谢谢观看！ 

ljxwwd
关注
专栏目录
中缀表达式转后缀表达式的实现
持续更新
09-26 233
而后缀表达式（也称为逆波兰表达式）则是以操作数在前，操作符在后的形式表示，例如"3 4 2 * +"。该算法利用栈数据结构和运算符的优先级来处理括号和运算符的关系，将中缀表达式转换为后缀表达式。实现中缀表达式转后缀表达式的关键在于设置运算符的优先级，并利用栈的特性来处理括号和优先级的关系。算法的基本思路是遍历中缀表达式的每个字符，对于不同的字符进行不同的处理。通过以上代码，我们可以将中缀表达式"3 + 4 * 2"成功转换为后缀表达式"342*+"。通过以上步骤，我们可以得到转换后的后缀表达式。
Python：从中缀表达式到后缀表达式的转换算法（含完整源码）
m0_47037246的博客
05-29 413
当我们遇到运算符时，我们可以弹出栈中任何优先级比当前运算符更高或与当前运算符相等的运算符，然后将它们添加到输出队列中。一旦我们处理了所有的输入，我们就可以从输出队列中读取后缀表达式的结果。最后，我们可以将堆栈中剩余的运算符弹出并添加到输出队列中，在此示例中只有一个*运算符。通过上述代码，我们可以将中缀表达式"A + (B * C) - D"转换为后缀表达式"A B C * + D -"。通过上述代码，我们可以将中缀表达式"A + (B * C) - D"转换为后缀表达式"A B C * + D -"。
Python学习日志0128 队列，中缀表达式转后缀表达式
weixin_44516568的博客
01-28 198
1.栈与队列的区别 （1）栈是只能在表的一端进行插入和删除操作的线性表，即先进后出（FILO），在栈中加入元素叫做入栈，从栈中删除元素叫做出栈。 （2）队列是能从队尾添加数据，从队头删除数据的线性表，即先进先出(FIFO) ，只能查看队头元素 2.普通队列的实现 通过列表完成对队列的实现，分别确定列表的两端为插入端和删除端，并将队列抽象为类，将先先进先出作为队列的方法 #普通队列 class...
栈的应用——中缀转后缀表达式
最新发布
qq_65297619的博客
08-23 658
中缀表达式转后缀表达式算法
[LeetCode]150. 逆波兰表达式求值
张小猪的家
08-28 798
150. 逆波兰表达式求值 难度：中等 根据 逆波兰表示法，求表达式的值。 有效的算符包括 +、-、*、/ 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。 说明： 整数除法只保留整数部分。 给定逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。 示例 1： 输入：tokens = ["2","1","+","3","*"] 输出：9 解释：该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9 示例 2： 输入：tokens = ["4","1
后缀表达式（是什么，如何转换）
qq_52847866的博客
10-16 5705
后缀表达式（也称为逆波兰表达式）是一种数学表达式的表示方法，其中操作符位于操作数的后面。这种表示法消除了括号，并且在计算机科学和计算中非常有用，因为它更容易计算和解析。与中缀表达式（通常我们使用的数学表达式，例如"a * (b + c)"）不同，后缀表达式的运算符放在操作数之后，例如：“a b c + *”。后缀表达式的计算方法是从左到右遍历表达式，遇到操作数时将其压入栈，遇到操作符时从栈中弹出所需数量的操作数进行计算，然后将结果重新压入栈。
中缀表达式转换为后缀表达式
热门推荐
__七把刀__
09-20 17万+
一、后缀表达式求值 后缀表达式也叫逆波兰表达式，其求值过程可以用到栈来辅助存储。假定待求值的后缀表达式为：6  5  2  3  + 8 * + 3  +  *，则其求值过程如下： 1）遍历表达式，遇到的数字首先放入栈中，此时栈如下所示： 2）接着读到“+”，则弹出3和2，执行3+2，计算结果等于5，并将5压入到栈中。 3）读到8，将其直接放入栈中。 4）读到“*”，弹出8和
中缀表达式转后缀表达式Python
qq_42907161的博客
08-17 346
中缀表达式转后缀表达式 参考的文章就是直接给出了算法，但是算法如何推导出来的还没有弄明白，简单记录下我自己的理解，强行解释一下。 后缀表达式就是操作符再操作数的后面，并且计算机能够根据简单的优先级就能进行运算。之前介绍手动形式转换中缀表达式的时候，首先需要把括号按照计算顺序添加完整，形成全括号表达式。如((a+b)*c)，然后再向外层移动。 可以看出来最终的结果ab+c*，操作数的相对位置是没有改变的。而操作符是仅仅跳出了本层括号。因此对于操作数，可以直接按原顺序排放，对于操作符，先保存起来，（当然，
中缀表达式转后缀表达式1
08-03
2. 只处理单个操作数，未涉及多位数操作数。 附录中的核心代码展示了Python实现的函数`reversePolishNotation(expression)`，该函数使用了栈来实现上述算法。当遇到数字时，将其添加到结果列表中；遇到运算符时，...
Python实现将中缀表达式转换为后缀表达式
2301_78484069的博客
06-03 276
如果是右括号，则弹出栈中的元素直到遇到左括号，并将所有弹出的操作符加入结果列表中；如果是操作符，则将其与栈顶的元素比较优先级，如果栈顶元素的优先级不低于当前操作符，则弹出栈顶元素并将其加入结果列表中，循环这个过程直到当前操作符的优先级高于栈顶元素或者栈为空，最后将当前操作符加入栈中。在计算机科学中，中缀表达式是最为常见的数学表达式表示方式，而在计算机中，后缀表达式（逆波兰表达式）更为容易处理和计算。最后，将栈中剩余的所有操作符依次弹出并加入结果列表中，最终将结果列表以空格为分隔符合并成字符串并返回即可。
python中缀式求值_中缀表达式求值问题
weixin_39669701的博客
12-05 761
中缀表达式求值问题中缀表达式的求值问题是一个比较常见的问题之一，我们通常在编写程序时，直接写出表达式让编译器去处理，很少去关心编译器是怎么对表达式进行求值的，今天我们来一起了解一下其中具体的原理和过程。表达式一般来说有三种：前缀表达式、中缀表达式、后缀表达式，其中后缀表达式又叫做逆波兰表达式。中缀表达式是最符合人们思维方式的一种表达式，顾名思义，就是操作符在操作数的中间。而前缀表达式和后缀表达式中...
中缀表达式转化为后缀表达式及计算的python实现-附完整代码
qq_45153782的博客
11-13 1920
中缀表达式转化为后缀表达式及计算中缀表达式转化为后缀表达式后缀表达式进行式子计算python程序实现 不扯别的了，开门见山！我们都见过一般的数学等式，如(9+(3−1)∗3+10/2)∗7(∗)(9+(3-1)*3+10/2)*7 \quad (*)(9+(3−1)∗3+10/2)∗7(∗)，计算机是如何快速识别进行计算并得到结果的呢？若我的文章给你有所帮助可以关注一波，感谢感谢！ 中缀表达式转化为后缀表达式 这里不再过多的介绍什么是后缀表达式了，不清楚的话点击后缀表达式，利用栈进行转变是一个很好的选择，指
python的中缀表达式转后缀表达式
2301_80246346的博客
11-17 584
因为直接引入一个Stack的库需要去官网下载，我这里就没有下载，直接自己定义了一个栈的类，它们的操作都是相同的，不用担心。self.items = [] -----初始化，先创建一个空的列表以完成接下来的stack的一系列操作。若opstack不为空的时候，便执行while循环-----按从栈顶依次弹出栈中元素到postfixlist中。对于第三行，是将传入的中序表达式以.split()-----以空格为分隔点，拆分成字符串集列表。为何将“(”---优先级为何最小？.join()-----连接在一起。
五分钟小知识之什么是后缀表达式
程序员吴师兄的博客
05-22 8226
点击蓝色“五分钟学算法”关注我哟加个“星标”，一起学算法后缀表达式，又称逆波兰式，指的是不包含括号，运算符放在两个运算对象的后面，所有的计算按运算符出现的顺序，严格从左向...
【数据结构】栈的应用-将中缀表达式转化为后缀表达式
qq_63234596的博客
04-06 1513
后缀表达式即逆波兰式，是卢卡西维奇（Lukasiewicz）于1929年发明的一种表示表达式的方法。区别于我们常用的中缀表达式（如2+3*5)，后缀表达式是将每个运算符放到操作数之后，没有优先级和括号，例如2 3 5 * +。
后缀表达式
liudongdong_jlu
06-21 8万+
后缀表达式：9 3 1-3*+ 10 2/+规则：从左到右遍历表达式的每个数字和符号，遇到是数字就进栈，遇到是符号，就将处于栈顶两个数字出栈，进行运算，运算结果进栈，一直到最终获得结果。下面是详细的步骤：1. 初始化一个空栈。此桟用来对要运算的数字进出使用。2. 后缀表达式中前三个都是数字，所以9、3、1进栈。3. 接下来是减号“-”，所以将栈中的1出栈作为减数，3出栈作为被减数，并运算3-1得到...
中缀表达式转前缀、后缀表达式（支持多位数字、小数的运算）
奋斗的龙猫的博客
07-07 3869
文章目录1.几种表达式的了解1.1中缀表达式1.1.1 定义1.1.2 计算1.2前缀表达式1.2.1 定义1.2.2 计算1.3后缀表达式1.3.1 定义1.3.2 计算2.中缀表达式转前缀、后缀表达式，并计算其值2.1 中缀表达式转后缀表达式2.1.1 思路2.1.2 代码实现：2.2 中缀表达式转前缀表达式2.2.1 思路2.2.2 代码实现： 1.几种表达式的了解 1.1中缀表达式 1.1.1 定义 所谓的中缀表达式，就是我们平常见到式子，比如 （ 3 + 4 ） * 5 - 6 1.1.2 计算
【数据结构】超详细讲解：算术表达式转化为后缀表达式、前缀表达式、表达式树的构建
Yaoyao2024的博客
04-22 1万+
中缀表达式：中缀表达式是我们常见的数学表达式，其中运算符放置在两个操作数中间，例如：3 + 4 * 2。在中缀表达式中，还可以包含括号，用于改变运算符的优先级。后缀表达式：后缀表达式（也称为逆波兰表达式）是一种将运算符放置在操作数后面的表达式，例如：3 4 2 * 1 5 - 2 ^ / +。在后缀表达式中，所有操作符的优先级相同，而括号则不再需要。前缀表达式：前缀表达式（也称为波兰表达式）是一种将运算符放置在操作数前面的表达式，例如：+ / * 3 4 2 ^ - 1 5 2。
Java实现中缀转后缀：步骤详解与代码示例
Java实现中缀表达式转后缀表达式的文章主要探讨了如何在编程中将中缀表达式转换成后缀表达式，这对于理解和处理复杂的数学运算逻辑非常有帮助。以下是从文章中提炼出的关键知识点： 1. **基本思路**: - 使用两个栈...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值