中缀表达式转后缀表达式与后缀表达式计算（详解）

已于 2023-12-05 15:48:11 修改
阅读量695 收藏 11
点赞数 7
文章标签： 数据结构 链表 visual studio c语言 visual code
于 2023-12-04 16:25:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45973003/article/details/134786846
版权

**中缀表达式转后缀表达式的一般步骤如下：
1：创建一个空的栈和一个空的输出列表。
2：从左到右扫描中缀表达式的每个字符。
3：如果当前字符是操作数，则直接将其加入到输出列表中。
4：如果当前字符是运算符，比较其与栈顶运算符的优先级：

  1. a. 如果栈为空或栈顶运算符是左括号"(“，则直接将当前运算符入栈。
    b. 如果当前运算符的优先级高于栈顶运算符的优先级，则将当前运算符入栈。
    c. 如果当前运算符的优先级低于或等于栈顶运算符的优先级，则将栈顶运算符弹出并加入到输出 列表中，
    直到栈为空或栈顶运算符的优先级低于当前运算符的优先级，然后将当前运算符入栈。
    d. 如果当前字符是右括号”)“，则依次弹出栈中的运算符并加入到输出列表中，
    直到遇到左括号”("为止，此时将左括号出栈且不加入输出列表。

    5：扫描完整个中缀表达式后，将栈中剩余的运算符依次弹出并加入到输出列表中。
    6：输出列表即为转换后的后缀表达式。
    举个例子：
    中缀表达式：2 + 3 * (4 - 1)
    转换为后缀表达式：2 3 4 1 - * +
    具体实现需要根据编程语言和数据结构来进行操作。    **
    在这里插入图片描述

项目结构
在这里插入图片描述项目头文件结构QueueStorage.h
在这里插入图片描述项目头文件代码

#ifndef LINKSTACK_H
#define LINKSTACK_H
#include <stdio.h>
#include <stdlib.h>
// 链式栈的节点
typedef struct LINKNODE {
	struct LINKNODE* next;
}LinkNode;
// 链式栈
typedef struct LINKSTACK {
	LinkNode head;
	int size;

}LinkStack;


// 初始化函数
LinkStack* Init_LinkStack();
// 入栈
void Push_LinkStack(LinkStack* stack, LinkNode* data);
// 出栈
void Pop_LinkStack(LinkStack* stack);
// 返回栈顶元素
LinkNode* TopLinkStack(LinkStack* stack);
// 返回栈元素的个数
int Size_LinkStack(LinkStack* stack);
// 清空栈
void Clear_LinkStack(LinkStack* stack);
// 销毁栈
void FreeSpace_LinkStack(LinkStack* stack);
#endif

项目cpp文件QueueStorage.cpp
在这里插入图片描述项目cpp文件代码QueueStorage.cpp

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <iostream>
#include <string.h>
#include "QueueStorage.h"

// 初始化函数
LinkStack* Init_LinkStack() {
    LinkStack* stack = (LinkStack*)malloc(sizeof(LinkStack));
    stack->head.next = NULL;
    stack->size = 0;
    return stack;
};
// 入栈
void Push_LinkStack(LinkStack* stack, LinkNode* data) {
    if (stack == NULL) {
        return;
    }
    if (data == NULL) {
        return;
    }
    // 入栈
    data->next = stack->head.next;
    stack->head.next = data;
    stack->size++;
};
// 出栈
void Pop_LinkStack(LinkStack* stack) {
    if (stack == NULL) {
        return;
    }
    if (stack->size == 0) {
        return;
    }

    // 第一个有效节点
    LinkNode* pNext = stack->head.next;
    stack->head.next = pNext->next;
    stack->size--;



};
// 返回栈顶元素
LinkNode* TopLinkStack(LinkStack* stack) {
    if (stack == NULL) {
        return NULL;
    }
    if (stack->size == 0) {
        return NULL;
    }
    // 返回栈顶元素
    return stack->head.next;
};

// 返回栈元素的个数
int Size_LinkStack(LinkStack* stack) {
    if (stack == NULL) {
        return -1;
    }
    return stack->size;
};
// 清空栈
void Clear_LinkStack(LinkStack* stack) {
    if (stack == NULL) {
        return;
    }
    // 清空栈
    stack->head.next = NULL;
    stack->size = 0;

};
// 销毁栈
void FreeSpace_LinkStack(LinkStack* stack) {
    if (stack == NULL) {
        return;
    }
    free(stack);
};

项目主文件截图
在这里插入图片描述项目主文件代码main.cpp

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <iostream>
#include <string.h>
#include "QueueStorage.h"


int IsNumber(char c) {
	return c >= '0' && c <= '9';
}
// 判断是不是左括号
int IsLeft(char c) {
	return c == '(';
}
// 判断是不是右括号
int IsRight(char c) {
	return c == ')';
}
// 判断是不是运算符号
int IsOperator(char c) {
	return c == '+' || c == '-' || c == '*' || c == '/';
}
//返回运算符号的优先级
int GetPriority(char c) {
	if (c == '*' || c == '/') {
		return 2;
	}
	if (c == '+' || c == '-') {
		return 1;
	}
	return 0;
}




//使用企业链表的方式进行实现需要添加结构体
typedef struct MYCHAR {
	LinkNode node;
	char* p;

}MyChar;


// 对于数字的操作
void NumberOperate(char* p) {
	printf("%c", *p);
}
// 创建MyChar
MyChar* CreateMyChar(char* p) {
	MyChar* mychar = (MyChar*)malloc(sizeof(MyChar));
	mychar->p = p;
	return mychar;
}

// 对于左括号的操作
void LeftOperate(LinkStack* stack,char* p) {
	Push_LinkStack(stack, (LinkNode*)CreateMyChar(p));
}
// 对于右括号的操作
void RightOperate(LinkStack* stack) {
	// 判断栈中是否存在元素
	while (Size_LinkStack(stack) > 0) {
		// 将里面的元素取出
		MyChar* mychar = (MyChar*)TopLinkStack(stack);
		// 如果匹配到左括号的话就弹出
		if (IsLeft(*(mychar->p))) {
			Pop_LinkStack(stack);
			break;
		}
		// 输出
		printf("%c", *(mychar->p));
		// 弹出
		Pop_LinkStack(stack);
		// 释放内存
		free(mychar);
	}
}
// 运算符号的操作
void OperatorOperate(LinkStack* stack, char* p) {
		

		// 取出栈顶符号
		MyChar* mychar = (MyChar*)TopLinkStack(stack);
		if (mychar == NULL) {
			Push_LinkStack(stack, (LinkNode*)CreateMyChar(p));
			return;
		}
		// 如果栈顶优先级低于符号的优先级直接入栈
		if (GetPriority(*(mychar->p) < GetPriority(*p))) {
			Push_LinkStack(stack,(LinkNode*)CreateMyChar(p));
			return;
		}
		else {
			// 如果栈顶符号优先级不低
			while (Size_LinkStack(stack) > 0) {

				 MyChar* mychar2 = (MyChar*)TopLinkStack(stack);

				// 如果优先级低当前的符号入栈
				if (GetPriority(*(mychar2->p)) < GetPriority(*p)) {
					Push_LinkStack(stack, (LinkNode*)CreateMyChar(p));
					break;
				}
				// 输出
				printf("%c ", *(mychar2->p));
				// 弹出
				Pop_LinkStack(stack);
				// 释放
				free(mychar2);
			}
		}
}

int main()
{
	/*
	    栈的应用：中缀表达式转后缀表达式

	*/
	char* str = (char *)"8 + (3 - 1) * 5";
	// 遍历字符串
	char* p = str;
	// 创建栈
	LinkStack* stack = Init_LinkStack();

	while (*p != '\0') {
	     // 判断是否数数字，如果是数字的话直接输出
		if (IsNumber(*p)) {
			NumberOperate(p);
		}
		// 判断是不是左括号，如果是左括号直接进栈
		if (IsLeft(*p)) {
			LeftOperate(stack,p);
		}
		// 如果是右括号的话将栈顶符号弹出知道匹配到左括号为止
		if (IsRight(*p)) {
			RightOperate(stack);
		}

		// 如果是运算符号的话
		if (IsOperator(*p)) {
			OperatorOperate(stack,p);
		}
		p++;
		
	}
	//将栈中剩余的元素弹出并输出
	while (Size_LinkStack(stack) > 0) {
		MyChar* mychar = (MyChar*)TopLinkStack(stack);
		printf("%c", *(mychar->p));
		Pop_LinkStack(stack);
		free(mychar);
	}

	system("pause");
	return 0;
}

修改运行界面
在这里插入图片描述在这里插入图片描述在这里插入图片描述项目运行结果

在这里插入图片描述
后缀表达式相关原理

在这里插入图片描述计算这个后缀表达式"2 3 4 1 - * +"。**

首先，我们从左到右扫描后缀表达式，遇到数字就将其入栈，遇到运算符则将栈顶的两个数字弹出进行计算，然后将结果入栈。
具体计算过程如下：

  1. 将2和3入栈
  2. 遇到4，入栈
  3. 遇到1，入栈
  4. 遇到减号"-"，弹出栈顶两个数字1和4，计算4-1=3，将结果3入栈
  5. 遇到乘号""，弹出栈顶两个数字3和3，计算33=9，将结果9入栈
  6. 遇到加号"+"，弹出栈顶两个数字9和2，计算9+2=11，将结果11入栈
  7. 后缀表达式扫描结束，栈顶的数字11即为最终的计算结果。

主文件
在这里插入图片描述
主文件截图
在这里插入图片描述主文件代码

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <iostream>
#include <string.h>
#include "QueueStorage.h"

int IsNumber2(char c) {
    return c >= '0' && c <= '9';
}
typedef struct MYNUM{
    LinkNode node;
    int val;

}MyNum;
int Calculate(int left,int right,char c) {
    int ret = 0;
    switch (c) {
       case '+':
            ret = left + right;
            break;
       case '-':
           ret = left - right;
           break;
       case '*':
           ret = left * right;
           break;
       case '/':
           ret = left / right;
           break;
         default:
            break;
    }
    return ret;
}


int main(void) {
    /*
       根据后缀表达式求解

    */
    char* str = (char *)"831-5*+";
    char* p = str;
    // 创建栈
    LinkStack* stack = Init_LinkStack();
    // 对后缀表达式进行扫描
    while (*p != '\0') {
        // 如果是数字直接入栈
        if (IsNumber2(*p)) {
            MyNum* num = (MyNum*)malloc(sizeof(MyNum));
            num->val = *p - '0';
            Push_LinkStack(stack,(LinkNode*)num);
        }
        else {
            MyNum* right = (MyNum*)TopLinkStack(stack);
            // 如果是运算符的话，先从栈中弹出右操作数
            int rightNum = right->val;
            Pop_LinkStack(stack);
            free(right);
            // 取出左操作数
            MyNum* left = (MyNum*)TopLinkStack(stack);
            int leftNum = left->val;
            Pop_LinkStack(stack);
            free(left);
            int ret = Calculate(leftNum, rightNum, *p);
            // 结果入栈
            MyNum* num = (MyNum*)malloc(sizeof(MyNum));
            num->val = ret;
            Push_LinkStack(stack, (LinkNode*)num);
        }
        p++;
    }
    if (Size_LinkStack(stack) == 1) {
        MyNum* num = (MyNum*)TopLinkStack(stack);
        printf("运算结果是%d\n", num->val);
        Pop_LinkStack(stack);
        free(num);
    }
    // 释放栈
    FreeSpace_LinkStack(stack);
    system("pause");
    return 0;
}

运行结果展示：
在这里插入图片描述

ETF_TT
关注
  • 7
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Java中缀表达式转后缀表达式实现方法详解
08-26
主要介绍了Java中缀表达式转后缀表达式实现方法,结合实例形式分析了Java中缀表达式转换成后缀表达式的相关算法原理与具体实现技巧,需要的朋友可以参考下
python实现逆波兰计算表达式实例详解
01-20
本文实例讲述了python实现逆波兰计算表达式的方法。分享给大家供大家参考。具体分析如下： 逆波兰表达式又叫做后缀表达式。在通常的表达式中，二元运算符总是置于与之相关的两个运算对象之间，所以，这种表示法也称为中缀表示。波兰逻辑学家J.Lukasiewicz于1929年提出了另一种表示表达式的方法。按此方法，每一运算符都置于其运算对象之后，故称为后缀表示。 # -*- coding: utf-8 -*- symbol_priority = {} symbol_priority[0] = ['#'] symbol_priority[1] = ['('] symbol_priority[2] =
JavaScript数据结构中栈的应用之表达式求值问题详解
10-20
主要介绍了JavaScript数据结构中栈的应用之表达式求值问题,详细分析了中缀表达式、后缀表达式等概念、原理与转换方法,以及基于后缀表达式实现的表达式求值相关操作技巧,需要的朋友可以参考下
中缀转后缀计算详解+代码
10-24
里面详述了中缀表达式怎么转化成后缀表达式以及怎么写才能计算任何带有小数的表达式。注释+技术实现文档，帮你理清楚思路。
中缀表达式转后缀表达式详解
罅隙的博客
08-25 2万+
深入讲解中缀表达式转后缀表达式的基本原理与实现代码
中缀表达式转换为后缀表达式（C语言代码+详解）
热门推荐
苍之羽
01-22 8万+
中缀表达式转换为后缀表达式 1.创建栈 2.从左向右顺序获取中缀表达式 a.数字直接输出 b.运算符 情况一：遇到左括号直接入栈，遇到右括号将栈中左括号之后入栈的运算符全部弹栈输出，同时左括号出栈但是不输出。 情况二：遇到乘号和除号直接入栈，直到遇到优先级比它更低的运算符，依次弹栈。 情况三：遇到加号和减号，如果此时栈空，则直接入栈，否则，将栈中优先级高的运算符依次弹栈（注意：加号和减号属于同一个...
中缀表达式转后缀表达式（Java）
weixin_48544279的博客
08-25 772
中缀表达式转后缀表达式 用栈和链表实现（Java）
每天一道算法题の中缀表达式转后缀表达式
黑虎阿福的博客
02-14 233
中缀表达式详解后缀表达式详解查看源码基本思路： 利用栈先进后出的特性去处理操作符
「Java 数据结构和算法」：图文详解---中缀表达式转后缀表达式。
yzh2776680982的博客
08-16 3340
栈是⼀个先⼊后出的有序列表。栈(stack)是限制线性表中元素的插⼊和删除只能在线性表的同⼀端进⾏的⼀种特殊线性表。允许插⼊和删除的⼀端，为变化的⼀端，称为栈顶(Top)，另⼀端为固定的⼀端，称为栈底(Bottom)。根据栈的定义可知，最先放⼊栈中元素在栈底，最后放⼊的元素在栈顶，⽽删除元素刚好相反，最后放⼊的元素最先删除，最先放⼊的元素最后删除。......
中缀表达式转后缀表达式程序C语言版
10-21
用C语言写的中缀转后缀程序...简单易懂适合初学数据结构的人参考
数据结构七：线性表之链式栈的设计
weixin_47040031的博客
04-27 610
从以上分析，我们可以知道链式栈只是单链表的一种特殊情况，限定了数据元素的插入和删除位置，链式栈是一种基于单链表实现的栈，在空间复杂度上，顺序栈在创建时就申请了数组空间，若栈经常处于不满状态将造成存储空间的浪费；链式栈所需空间是根据需要随时申请的，比之顺序栈仅仅是其每个结点需要额外的空间以存储其next指针域。在时间复杂度上，对于针对栈顶的基本操作（压入、弹出和栈顶元素存取），容易看出，顺序栈和链式栈的时间复杂性均为O(1)。
【数据结构6--图】
w384829981的博客
04-24 760
图（Graph）是一种数学结构，用于表示对象之间的关系。在图中，通常包含以下元素：一些简单的概念术语就不讨论了，例如:提醒一点下图是一个图还是4个图？（一个图，千万别说成四个图）(x,y)指由x点到y点，且无方向；也就是（x,y)=(y,x);指由x到y，但是有方向；也就是!=;什么是顶点？什么是边？什么是图？什么是子图？—就是从一个图中拿走一部分，这部分就是子图，隶属关系什么是有向图？—只要有一根线带方向就是有向图什么是完全有向图？
数据结构之栈
qq_74336191的博客
04-24 836
栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除操作。进入数据插入和删除操作的一端称为栈顶，另一端称为栈底。
数据结构 ： 树的分类及在数据库索引中的运用
最新发布
simensk的博客
04-27 663
树 数据库索引 b树 b+树
学习笔记-数据结构-树与二叉树（2024-04-23）
XuJiaKai的博客
04-24 167
这是因为每个叶节点都有2个空指针，每个度为1的节点都有1个空指针，空指针总数为2n0+n1，又因为n0=n2+1，所以空指针的总数为n0+n1+n2+1=n+1。附设指针pre指向刚刚访问过的节点，指针p指向正在访问的节点，即pre指向p的前驱。在中序遍历的过程中，检查p的左指针是否为空，若为空就将它指向pre；若无右子树，令rchhild指向其后继节点，还需要增加两个标志域，以标识指针域指向左（右）孩子或前驱（后继）。二叉树的线索化是将二叉链表中的空指针改为指向前驱或后继的线索。
【高阶数据结构】B树 {B树的概念；B树的实现：节点设计，查找，插入，遍历，删除；B树的性能分析；B+树和B*树；B树的应用}
芥末虾的博客
04-24 756
【高阶数据结构】B树 {B树的概念；B树的实现：节点设计，查找，插入，遍历，删除；B树的性能分析；B+树和B*树；B树的应用}
学习笔记-数据结构-线性表（2024-04-23）
XuJiaKai的博客
04-24 136
指针La和Lb分别是两个带头节点单链表的头指针，将表La的第i个元素其len个元素删除并插入到表Lb的第j（j>=1）个元素之前。将La中的第i个元素开始的Len个元素插入到Lb中的第j个位置。
数据结构（并查集，ST表）
m0_50269977的博客
04-27 89
【代码】数据结构（并查集，ST表）
Java：二叉树（1）
wu_yi_min的博客
04-21 615
树是一种非线性的数据结构，它是由n（n>=0)个有限结点组成的具有层次关系的集合。把它叫成树，是因为它看起来很像棵倒挂的树，也就是说，它是根朝上，叶朝下的。树具有以下几个特点：1、有一个特殊的结点，称为根结点，它没有前驱结点。2、除了根结点以外，其余结点被分为M（M>0)个互不相交的集合T1 、T2 、T3 ……Tm,其中每一个集合又是一棵类似的子树。二叉树是结点的一个有限集合，该集合1、或者为空2、或是是由一个根结点加上两棵分别称为左子树和右子树的二叉树组成！那为什么称为二叉树？
详解中缀表达式转后缀表达式
11-26
中缀表达式转后缀表达式的具体步骤如下： 1. 初始化两个栈：运算符栈s1和储存中间结果的栈s2； 2. 从左至右扫描中缀表达式； 3. 遇到操作数时，将其压s2； 4. 遇到运算符时，比较其与s1栈顶运算符的优先级： 1. ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值