【C】【Stack】中缀转后缀进行四则运算

已于 2022-03-28 09:01:17 修改
阅读量128 收藏
点赞数
分类专栏： 自学C 文章标签： c语言 开发语言 学习
于 2022-03-27 18:32:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52755873/article/details/123778395
版权

中缀表达式转后缀表达式并进行运算

可进行简单四则运算

#include<stdio.h>
#include<stdbool.h>
#include<stdlib.h>
#include<string.h>

typedef struct data {
	int num;
	char oper;
}Item;

typedef struct node {
	Item item;
	struct node* next;
}Node;

typedef struct {
	Node* top;
	Node* bottom;
	int node_num;
}Stack;

bool InitStack(Stack* pstack);//初始化栈
bool StackIsEmpty(Stack* pstack);//判断栈是否为空
bool StackIsFull(Stack* pstack);//判断栈是否已满
bool PushStack_char(Stack* pstack, char oper);//进栈，运算符
bool PushStack_int(Stack* pstack, int num);//进栈，数字
bool PopStack(Stack* pstack);//出栈
char GetTop(Stack* pstack);//获取栈顶元素
bool PrintStack(Stack* pstack);//打印全体栈元素
bool FreeStack(Stack* pstack);//释放栈
bool ComOper(Stack* pstack, char ch);//运算符比较
void FunLz(Stack* ptemp, Stack* poper);//中缀转后缀
void InvertSeq(Stack* ptemp, Stack* pfinal);//逆序
void Compute(Stack* pfinal, Stack* pcom);//计算后缀表达式

bool InitStack(Stack* pstack)
{
	pstack->node_num = 0;
	pstack->top = (Node*)malloc(sizeof(Node));
	pstack->bottom = NULL;
	pstack->top->next = pstack->bottom;

	if (pstack->bottom != NULL)
		return false;
	if (pstack->top->next != pstack->bottom)
		return false;

	return true;
}

bool StackIsEmpty(Stack* pstack)
{
	bool empty = true;

	if (pstack->node_num == 0)
		return empty;
	else return !empty;
}

bool StackIsFull(Stack* pstack)
{
	bool full = true;
	Node* ptemp;
	ptemp = (Node*)malloc(sizeof(Node));

	if (ptemp == NULL)
	{
		free(ptemp);
		return full;
	}
	else
	{
		free(ptemp);
		return !full;
	}
}

bool PushStack_char(Stack* pstack, char oper)
{
	Node* pnew;
	pnew = (Node*)malloc(sizeof(Node));
	if (pnew == NULL)
		return false;
	pnew->item.oper = oper;

	if (StackIsEmpty(pstack) == true)
	{
		pnew->next = pstack->bottom;//新节点指向栈底
		pstack->top = pnew;//新节点变成栈顶
		pstack->node_num++;//节点计数增加
		return true;
	}

	if (StackIsEmpty(pstack) == false)
	{
		pnew->next = pstack->top;//新节点指向栈顶
		pstack->top = pnew;//新节点变成“真”栈顶
		pstack->node_num++;//节点计数增加
		return true;
	}

	return false;
}

bool PushStack_int(Stack* pstack, int num)
{
	Node* pnew;
	pnew = (Node*)malloc(sizeof(Node));
	if (pnew == NULL)
		return false;
	pnew->item.num = num;
	pnew->item.oper = '=';//做一个标识

	if (StackIsEmpty(pstack) == true)
	{
		pnew->next = pstack->bottom;//新节点指向栈底
		pstack->top = pnew;//新节点变成栈顶
		pstack->node_num++;//节点计数增加
		return true;
	}

	if (StackIsEmpty(pstack) == false)
	{
		pnew->next = pstack->top;//新节点指向栈顶
		pstack->top = pnew;//新节点变成“真”栈顶
		pstack->node_num++;//节点计数增加
		return true;
	}

	return false;
}

bool PopStack(Stack* pstack)
{
	Node* ptemp;
	
	if (StackIsEmpty(pstack) == true)
	{
		printf("栈空！无法出栈！\n");
		return false;
	}
	else
	{
		ptemp = pstack->top;//临时节点保存栈顶
		pstack->top = pstack->top->next;//栈顶向前推进
		free(ptemp);//释放原栈顶
		pstack->node_num--;//节点计数减少
		return true;
	}
}

char GetTop(Stack* pstack)
{
	if (StackIsEmpty(pstack) == true)
	{
		printf("栈空！无法获取栈顶元素！\n");
		return false;
	}
	else
		return pstack->top->item.oper;
}

bool PrintStack(Stack* pstack)
{
	Node* pscan = pstack->top;//获取当前栈顶
	if (StackIsEmpty(pstack) == true)
	{
		printf("栈空！无法打印栈元素！\n");
		return false;
	}
	else
	{
		printf("全体栈元素：");
		while (pscan != NULL)
		{
			if (pscan->item.oper == '=')
				printf("%d ", pscan->item.num);
			else
				printf("%c ", pscan->item.oper);
			pscan = pscan->next;//向前
		}
		putchar('\n');
		return true;
	}
}

bool FreeStack(Stack* pstack)
{
	Node* ptemp = pstack->top;//获取当前栈顶

	if (StackIsEmpty(pstack) == true)
	{
		printf("栈空！无需释放！\n");
		return false;
	}
	else
	{
		//栈顶非空时
		while (ptemp != NULL)
		{
			pstack->top = pstack->top->next;//栈顶向前
			free(ptemp);//释放原栈顶
			ptemp = pstack->top;//保存当前栈顶
		}
		return true;
	}
}

bool ComOper(Stack* pstack, char ch)
{
	bool greater = true;
	bool equal = false;
	bool less = false;
	
	if (ch == '*' || ch == '/')
	{
		if (GetTop(pstack) == '*' || GetTop(pstack) == '/')
			return equal;
		else
			return greater;
	}
	else if (ch == '+' || ch == '-')
		return less;
	else
		return false;
}

void FunLz(Stack* ptemp, Stack* poper)
{
	char ch = '=', temp;
	int n, num;
	char num_char[10] ={'#'};
	int i = 0;
	bool flag = true;//用来判断最后中缀表达式最后一位是不是数字

	do {
		//进行输入
		scanf_s("%c", &ch, (int)sizeof(char));
		//if(ch != '=')
			//printf("输入%c\n", ch);

		//'='停止输入
		if (ch == '=')break;
		//为数字存入num字符数组
		else if (ch >= '0' && ch <= '9')
		{
			flag = true;
			num_char[i] = ch;
			i++;
		}
		//为运算符时
		else
		{
			flag = false;

			//没有输入过数字不能进行以下操作
			if (num_char[0] != '#')
			{
				num_char[i] = '\0';//变成字符串
				num = atoi(num_char);//字符串转数字
				PushStack_int(ptemp, num);//数字入临时结果栈
				//printf("%d进临时结果栈\n", num);
				for (int n = 0; n < 10; n++)
					num_char[n] = '#';
				i = 0;
			}

			//如果 “运算符栈空” 或 “输入的为'('” 时，直接压入运算符栈
			if (StackIsEmpty(poper) == true || ch == '(')
			{
				PushStack_char(poper, ch);
				//printf("%c进运算符栈\n", ch);
			}
			//输入')'时
			else if (ch == ')')
			{
				//到运算符栈顶元素为'('止
				while (GetTop(poper) != '(')
				{
					temp = GetTop(poper);
					PopStack(poper);
					//printf("%c出运算符栈\n", temp);
					PushStack_char(ptemp, temp);
					//printf("%c进临时结果栈\n", temp);
				}
				PopStack(poper);//把'('出运算符栈
				//printf("(出运算符栈\n");
			}
			//括号输入已经处理完毕
			//运算符栈顶元素为'('
			else if (GetTop(poper) == '(')
			{
				PushStack_char(poper, ch);
				//printf("%c进运算符栈\n", ch);
			}
			else
			{
				//如果优先级高
				if (ComOper(poper, ch) == true)
				{
					PushStack_char(poper, ch);
					//printf("%c进运算符栈\n",ch);
				}
				//如果优先级低或相同
				else
				{
					temp = GetTop(poper);
					PopStack(poper);
					//printf("%c出运算符栈\n", temp);
					PushStack_char(ptemp, temp);
					//printf("%c进临时结果栈\n", temp);
					PushStack_char(poper, ch);//将输入的ch入栈
					//printf("%c进运算符栈\n", ch);
				}
			}
		}
		/*		if (StackIsEmpty(ptemp) == false)
		{
			printf("临时结果");
			PrintStack(ptemp);
		}
		if (StackIsEmpty(poper) == false)
		{
			printf("运算符");
			PrintStack(poper);
		}
		putchar('\n');*/
		
	} while(ch != '=');

	//当中缀表达式最后不是运算符时，最后一个数字要独立输出，如1+2
	if (flag == true)
	{
		num_char[i] = '\0';//变成字符串
		num = atoi(num_char);//字符串转数字
		PushStack_int(ptemp, num);//数字入临时结果栈
		//printf("%d进临时结果栈\n", num);
	}

	//处理剩余内容
	while (getchar() != '\n')
		continue;

	
	//将运算符栈剩余内容压入临时结果栈
	n = poper->node_num;
	while (n--)
	{
		temp = GetTop(poper);
		PopStack(poper);
		//printf("%c出运算符栈\n", temp);
		PushStack_char(ptemp, temp);
		//printf("%c进临时结果栈\n", temp);
		/*		if (StackIsEmpty(ptemp) == false)
		{
			printf("临时结果");
			PrintStack(ptemp);
		}

		if (StackIsEmpty(poper) == false)
		{
			printf("运算符");
			PrintStack(poper);
		}

		putchar('\n');*/
	}
}

void InvertSeq(Stack* ptemp, Stack* pfinal)
{
	char temp_oper;
	int temp_num;
	while (StackIsEmpty(ptemp) == false)
	{
		if (GetTop(ptemp) == '=')
		{
			temp_num = ptemp->top->item.num;
			PopStack(ptemp);
			PushStack_int(pfinal, temp_num);
		}
		else
		{
			temp_oper = ptemp->top->item.oper;
			PopStack(ptemp);
			PushStack_char(pfinal, temp_oper);
		}
	}
}

void Compute(Stack* pfinal, Stack* pcom)
{
	char temp_oper;
	int temp_num;
	int num[2] = { 0 };
	
	printf("\n开始运算……\n");

	while (StackIsEmpty(pfinal) == false)
	{
		//如果是数字
		if (GetTop(pfinal) == '=')
		{
			temp_num = pfinal->top->item.num;
			PopStack(pfinal);
			PushStack_int(pcom, temp_num);
		}
		//如果是运算符
		else
		{
			int i = 0;
			temp_oper = pfinal->top->item.oper;
			PopStack(pfinal);

			//当运算栈节点数大于等于2时
			if (pcom->node_num >= 2)
			{
				//将两个数字出栈准备进行运算
				for (i = 0; i < 2; i++)
				{
					num[i] = pcom->top->item.num;
					PopStack(pcom);
				}
			}
			switch (temp_oper)//判断运算符
			{
			case'+':
				temp_num = num[1] + num[0]; break;
			case'-':
				temp_num = num[1] - num[0]; break;
			case'*':
				temp_num = num[1] * num[0]; break;
			case'/':
				temp_num = num[1] / num[0]; break;
			default:
				temp_num = 0;
			}
			PushStack_int(pcom, temp_num);
		}
	}

	printf("运算结果：%d\n", pcom->top->item.num);
}

int main()
{
	Stack S1;//临时结果栈
	Stack S2;//运算符栈
	Stack S3;//最终结果栈
	Stack S4;//运算栈

	if (InitStack(&S1) && InitStack(&S2) && InitStack(&S3) && InitStack(&S4))
		printf("程序运行……\n");
	else
		exit(1);

	if (StackIsFull(&S1) == false && StackIsFull(&S2) == false)
		FunLz(&S1, &S2);
	else
		exit(1);

	/*if (StackIsEmpty(&S1) == false)
	{
		printf("临时结果");
		PrintStack(&S1);
	}*/

	InvertSeq(&S1, &S3);
	if (StackIsEmpty(&S3) == false)
	{
		printf("最终结果");
		PrintStack(&S3);
	}

	Compute(&S3, &S4);

	return 0;
}

注释为测试代码
本方法基于【C】【Stack】链栈实现中缀转后缀

Reverse-Flash
关注
专栏目录
四则运算中缀转后缀(C语言)
DFGOMC的博客
10-12 391
四则运算中缀转后缀(C语言) 本文参考自《大话数据结构》 算法思路 遇到数字直接输出，使用栈来存储，通过比较运算符的优先级，判断是否要将栈顶符号输出： 如果栈顶符号优先级不比字符串当前所指符号优先级低，则输出；否则将符号入栈； 括号优先级最高()，遇到 ) 括号则匹配栈中的 **( ** 括号，将括号中所有符号输出； 字符串遍历结束后，将栈中符号全部输出； 原书例题 9+(3-1)*3+10/2： 数字9直接输出，输出结果：9 栈为空，栈中没有符号，此时+号入栈，栈中符号为（左边为栈顶）：+ (
栈-中缀表达式转后缀表达式(stack实现)
JKR10000的博客
06-21 1185
题目描述 输入一个中缀表达式，编程输出其后缀表达式，要求输出的后缀表达式的运算次序与输入的中缀表达式的运算次序相一致。为简单起见，假设输入的中缀表达式由＋（加）、－（减）、×（乘）、／（除）四个运算符号以及左右圆括号和英文字母组成，其中算术运算符遵守先乘除后加减的运算规则。假设输入的中缀表达式长度不超过300个字符，且都是正确的，即没有语法错误，并且凡出现括号其内部一定有表达式，即内部至少有一个运算符号。 中缀表达式转后缀表达式的方法： 1.遇到操作数：直接输出（添加到后缀表达式中） 2.栈为空时，遇到运算
C语言中缀转后缀四则运算--For初学者
a_52hz的博客
09-26 1811
中缀表达式 百度百科 后缀表达式 百度百科 现在大家都知道了什么是中缀表达式，后缀表达式。好，进正题。本文主要是用C语言，来做简单的编程实现转化功能。 例如，输入 ：(5+3)*2+(6+3) 转化后的结果：5 3 + 2 * 6 3 + +（后附有图） 额，本人能力有限，所以难免有bug，读者在运行代码的时候，括号的输入是英文的（可以自行加上中文），注意输入格式。 代码如下： 编译环境是（Cod...
C语言之四则表达式的计算（中缀转后缀）
Dr.Ning的博客
04-16 923
如何通过栈来实现四则运算表达式的计算思路代码结果和总结测试案例总结 思路 通过栈这种数据结构来实现四则运算表达式的计算，是C语言这门课程中一项经典的作业。大一刚上C语言这门课的时候老师给我们的期末大作业就是这道题。总的来说我们需要做的最主要的一项工作就是把中缀表达式转为后缀表达式，这就需要用到栈中数据“先进后出”的特性。中缀、后缀表达式的概念这里不再赘述，后文运算结果截图也有展示。栈有两种形式：顺...
栈实现四则运算
ArthurWang的专栏
07-15 583
#include #include  //header file of isdigit#define MAXSIZE 100//the max length of the expresionchar ch[7] = {'+','-','*','/','(',')','#'};i
四则运算（中缀转后缀）
12-12
以上就是使用C语言实现中缀表达式转后缀表达式的基本思路。实际编写代码时，还需要处理更多细节，例如错误检查、字符串处理、输入验证等。通过这个过程，我们可以更好地理解计算机如何解析和计算数学表达式，这对于...
四则运算的中缀转后缀，逆波兰表达式求值
03-05
本主题主要涉及两个关键知识点：中缀表达式转后缀表达式和逆波兰表达式求值。 1. **中缀表达式转后缀表达式**： - **算法思想**：使用两个栈，一个用于存储操作数，一个用于存储运算符。遍历中缀表达式的每个字符...
数据结构之栈（中缀转后缀计算四则运算）
tulensa的博客
01-26 753
前面转载了一篇有关栈的基础讲解的文章，所以这篇文章就不再说有关栈的概念性内容了。这篇文章主要的内容，就是用学到的栈的基础操作，来实现一个输入中缀四则运算表达式（+ - * /），转换成后缀表达式，然后计算结果并输出的小程序。表达式中可以有括号，操作数可以是多位整数（不支持小数，不过要修改也很容易）。中缀转后缀方法：1.遇到操作数，直接输出； 2.栈为空时，遇到运算符，入栈； 3.遇到左括号，将其入...
使用栈实现四则运算中缀到后缀的转换
YoungLittleT的博客
05-09 281
使用栈实现四则运算中缀到后缀的转换，代码如下： package com.mytest; import java.util.Stack; public class MyTest { public static void main(String[] args) { String[] infixExpression = { "9", "+", "(", "3", "-", "1", ")", "*", "3", "+", "10", "/", "2" };// 中缀表达式 ...
Stack栈之四则运算（取需）
lanwei
06-15 387
package Lanwei_20150615Stack_Operate; import java.util.Stack; /** * 利用栈，进行四则运算的类 用两个栈来实现算符优先，一个栈用来保存需要计算的数据numStack,一个用来保存计算优先符priStack * * 基本算法实现思路为：用当前取得的运算符与priStack栈顶运算符比较优先级：若高于，则因为...
数据结构栈Stack之中缀表达式转后缀表达式运算应用
纳兰小筑
08-09 505
使用Java中的Stack数据结构编写的，中缀表达式转后缀表达式并进行运算的类，正在学习数据结构栈的小伙伴可以参考一下，大家一起学习
算法刷题笔记-stack-四则运算
weixin_33805743的博客
06-23 215
题目描述： 给定一个含有数字和运算符的字符串，为表达式添加括号，改变其运算优先级以求出不同的结果。你需要给出所有可能的组合的结果。有效的运算符号包含 +, - 以及 * 。 示例 1: 输入: "2-1-1"输出: [0, 2]解释: ((2-1)-1) = 0 (2-(1-1)) = 2 来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/dif...
使命栈（stack）实现一个简易的四则运算计算器
头像是我的偶像的专栏
08-12 837
运算过程比较简单。在VC控制台输入 四则运算表达式，以按下回车键来获取运算结果。退出控制台，按下CTRL + 'Z'。 /* * calculator.cpp */ #include #include #include "stack.h" #define EXP_MAX_SIZE 64 char infix_exp[EXP_MAX_SIZE]; int po
利用Stack进行四则运算表达式求值
weixin_41779489的博客
05-14 690
题目：请利用Stack把字符串中缀表达式编译为后缀表达式，然后再利用栈执行后缀表达式获得计算结果。 中缀表达式转为后缀表达式： 1.按次序读取中缀表达式的字符。 2.读到一个操作数的时候，立即放入到输出中。 3.读到操作符“+”，“-”，“*”，“/”，则从栈中弹出栈元素并输出，直到遇到优先级更低或者“(”的为止操作符为止（该元素不出栈）。 4.读到操作符“(”，则直接把“(”压入栈中。 5.读到操作符“)”，则从栈中弹出栈元素并输出，直到遇到第一个“(”为止。其中“(”不再添加到输出中，而是直接舍弃。
通过栈stack和队列queue实现将中缀表达式转化成后缀表达，非常详细，有图有真相哦~，一定要看到最后哦
✈ 正在努力 の 寒江（StudiousTiger) ✌ 呐 ✈
05-19 541
声明： 我们需要用到两个数据结构栈（Stack）和队列（Queue）,其中Stack用来存放扫描到的字符，Queue用来存放后缀表达式。 入栈和入队时需要遵循以下的四条原则： 1.栈顶运算符遇到“(”，入栈 2.栈顶运算符遇到“)”，出栈并将出栈的运算符入队，直到遇到“)”结束入队，并将“)”出栈 3.栈顶运算符遇到同级运算符，出栈并出队的运算符入队 4.栈顶运算符遇到低级的运算符，出栈并将出栈的运算符入队，最后将低级的运算符入栈 5.栈顶运算符遇到高级的运算符，入栈 6.遇到运算数直接入队
利用栈Stack将包含括号的四则运算转为后缀表达式并计算结果
qq_42921483的博客
02-18 235
//利用堆栈计算后缀表达式 //定义正则,判断是否是数字或者小数点 private final Pattern pattern = Pattern.compile("[0-9.]*"); @Test public void test() { String formula_began = "11.1-(2.2/3.3)+(9.9*8.8/(7.7-(6.6*5.5+4.4)))"; ...
C Primer Plus第六版 第十四章编程练习
o707191418的博客
09-06 2506
1. #include &lt;stdio.h&gt; #include &lt;string.h&gt; #include &lt;ctype.h&gt; #include &lt;stdbool.h&gt; #define LEN 4 struct month{ char name[LEN]; int days; int monumb; }; struct mo...
C语言12周作业（指针与数组）
Cachel Wood的博客
11-25 350
1. #include <stdio.h> #include <stdbool.h> #define ROW 3 #define COLUMN 4 bool search(int [ROW][COLUMN],int); int main(){ int temperatures[ROW][COLUMN]; int *s = &temperatures[0][0]; printf("enter %d numbers:",ROW*COLUMN);
堆栈实现中缀表达式转为后缀表达式
ailunlee的博客
01-29 5449
堆栈实现中缀表达式转为后缀表达式 （1）规则        中缀表达式转为后缀表达式也有一定的规则，这个规则是根据操作符的运算优先级来定的转为后缀表达式的规则为： 如果遇到操作数，我们就直接将其输出。 如果遇到操作符，则我们将其放入到栈中，遇到左括号时我们也将其放入栈中。 如果遇到一个右括号，则将栈元素弹出，将弹出的操作符输出直到遇到左括号为止。注意，左括号只弹出并不输出。 如果遇到任...
C++实现中缀转后缀表达式及四则运算
本篇文章主要介绍了如何使用C++语言实现中缀表达式（Infix Expression）到后缀表达式（Postfix Expression）的转换，并包含了基本的算术运算，如加减乘除。以下是对文章核心知识点的详细解析： 1. **栈数据结构的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值