C代码 中序表达式到后序表达式 转换

已于 2023-01-06 10:59:09 修改
阅读量656 收藏 4
点赞数 4
分类专栏： 数据结构 文章标签： 数据结构
于 2023-01-06 10:58:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/debug_h/article/details/128547853
版权

一，条件及要求

1，表达式必须是合法的

2，表达式必须遵循普通的优先级法则

3，默认运算符为   *   、  +  、 （   、 ）、-

二，对后序（后缀）表达式的理解

后序表达式本质上讲：想象一个栈空间，对于一个后序表达式，如果读到数字，则入栈，如果读到运算符，则从栈顶取出两个元素用该运算符进行计算，并将计算结果压入栈，重复该步骤直到表达式读取完毕。

三，分析

eg:    中序表达式          a+b                       其后序表达式为:   a b +

          中序                    a  + b * c                    后序表达式为:  a   b    c   *   +

         中序                     a  +  b * c + d            后序表达式为： a  b   c  *  +   d  +

         中序                     a  +  b * c  +  d * e      后序表达式为： a  b  c  *  +   d   e  * +

我们肯定要用到栈。如果读到操作数则直接输出，如果读到操作符则应该入栈。

   当读到一个操作数的时候，立即把它放到输出中。操作数不立即输出，所以必须先存在某个地方中，正确的做法是将所有见过的操作符放在栈中，当遇到左圆括号时我们也要将其入栈。我们从空栈开始计算。

    如果见到有括号，那么就将栈中元素弹出直到遇见一个左括号，这个左括号只弹出而不输出。

    如果见到其他的运算符，那么我们从栈中弹出栈元素直到发现优先级更低的元素为止。（就是要求栈顶的操作符的优先级必须比上一个元素的优先级要高，括号除外）。

注意，+ 的优先级最低，（ 的优先级最高

最后如果读到了输入的末尾，我们将栈元素弹出直到该栈变为空栈

说不清楚，寄

四，代码实现

1，创建结构体，用数组模拟栈

#include<stdio.h>
#include<stdlib.h>
#define MaxStackSize (20)   //栈最大容量
#define EmtpyInStack (-1)   //栈空时，栈顶所在位置

struct StackRecord {
	int Capacity;  //容量
	int TopOfStack; //栈顶位置
	char* Array;  //栈空间
};
typedef struct StackRecord *Stack;

2，需要对栈进行初始化

Stack CreatStack(int SizeOfstack) //创建栈空间,并且初始化
{
	Stack s = malloc(sizeof(struct StackRecord));
	if (s == NULL)
	{
		printf("error in create stack");
		exit(0);
	}

	s->Array = malloc(sizeof(char) * SizeOfstack);
	if (s->Array == NULL)
	{
		printf("error in create array in stack");
		exit(0);
	}

	s->Capacity = SizeOfstack;
	s->TopOfStack = EmtpyInStack;
}

3，我们应该还要注意到，在表达式中的操作数应该最好是字母，这样我们可以把表达式存入字符数组从而来每次只读一个字符进行操作，如果由数字组成，读取时会比较麻烦。

4，总体代码如下

#define _CRT_SECURE_NO_WARNINGS

#include<stdio.h>
#include<stdlib.h>
#define MaxStackSize (20)   //栈最大容量
#define EmtpyInStack (-1)   //栈空时，栈顶所在位置

struct StackRecord {
	int Capacity;  //容量
	int TopOfStack; //栈顶位置
	char* Array;  //栈空间
};
typedef struct StackRecord *Stack;

Stack CreatStack(int SizeOfstack) //创建栈空间,并且初始化
{
	Stack s = malloc(sizeof(struct StackRecord));
	if (s == NULL)
	{
		printf("error in create stack");
		exit(0);
	}

	s->Array = malloc(sizeof(char) * SizeOfstack);
	if (s->Array == NULL)
	{
		printf("error in create array in stack");
		exit(0);
	}

	s->Capacity = SizeOfstack;
	s->TopOfStack = EmtpyInStack;
}

int JudgeEmpty(Stack s)
//判断是否栈空
{
	return s->TopOfStack == EmtpyInStack;
}
//弹出栈
char GetOutStack(Stack s)
{
	if (JudgeEmpty(s))
	{
		printf("表达式错误,存在栈为空的情况");
		exit(0);
	}
	//s->TopOfStack--;
	return s->Array[s->TopOfStack--];
}
int JudgeFullStack(Stack s)
{
	return s->TopOfStack + 1 == s->Capacity;
}
void GetInStack(char a, Stack s)
//压入栈
{
	if (JudgeFullStack(s))
	{
		printf("表达式错误,导致出现栈满");
		exit(0);
	}
	s->TopOfStack++;
	s->Array[s->TopOfStack] = a;
}
int main()
{
	int i;
	//创建链表
	Stack s = CreatStack(MaxStackSize);

	char arr[20] = { 0 };
	gets(arr);


	for (i = 0; arr[i] != '\0'; i++)
	{
		if(arr[i] >= 'a' && arr[i] <= 'z')
		{
			printf("%c", arr[i]);
		}
		//如果此时栈顶的元素的优先级比读入的低，则可以进去
		//如果此时栈顶元素的优先级和读入的相等，也应该输出。
		else if (arr[i] == '+'||arr[i]=='-')

		{
			if (JudgeEmpty(s) == 0) {//不为空，则判断是否需要弹出栈
				while (s->Array[s->TopOfStack] != '(')
				{
					char out = GetOutStack(s);
					printf("%c", out);
					if (JudgeEmpty(s))
					{
						break;
					}
				}
			}
			GetInStack(arr[i], s);//入
			
		}
		else if (arr[i] == '*'||arr[i]=='/')
			//这两个运算符的优先级是相同的
		{
			if (JudgeEmpty(s) == 0) {
				while (s->Array[s->TopOfStack] != '+' &&
			s->Array[s->TopOfStack] != '('&&s->Array[s->TopOfStack]!='-')
				{
					char out = GetOutStack(s);
					printf("%c", out);
					if (JudgeEmpty(s))
					{
						break;
					}
				}
			}

			GetInStack(arr[i], s);
		}

		else if (arr[i] == '(')
			//无条件入栈。优先级最高
		{
			GetInStack(arr[i], s);
		}

		else if(arr[i]==')')
			 //找到对应的（，并且不用输出
		{
			char out = GetOutStack(s);
			while (out != '(')
			{
				printf("%c", out);
				out = GetOutStack(s);
			}
		}
	}


	//将栈弹空
	while (JudgeEmpty(s) == 0)
	{
		printf("%c", GetOutStack(s));
	}

	return 0;
}

这里，，用字母代表数字，，感觉有点lou,,,可以改进一下，用数字，因为这里不需要用到计算，优化还是比较方便的。。

#define _CRT_SECURE_NO_WARNINGS

#include<stdio.h>
#include<stdlib.h>
#define MaxStackSize (20)   //栈最大容量
#define EmtpyInStack (-1)   //栈空时，栈顶所在位置

struct StackRecord {
	int Capacity;  //容量
	int TopOfStack; //栈顶位置
	char* Array;  //栈空间
};
typedef struct StackRecord *Stack;

Stack CreatStack(int SizeOfstack) //创建栈空间,并且初始化
{
	Stack s = malloc(sizeof(struct StackRecord));
	if (s == NULL)
	{
		printf("error in create stack");
		exit(0);
	}

	s->Array = malloc(sizeof(char) * SizeOfstack);
	if (s->Array == NULL)
	{
		printf("error in create array in stack");
		exit(0);
	}

	s->Capacity = SizeOfstack;
	s->TopOfStack = EmtpyInStack;
}

int JudgeEmpty(Stack s)
//判断是否栈空
{
	return s->TopOfStack == EmtpyInStack;
}
//弹出栈
char GetOutStack(Stack s)
{
	if (JudgeEmpty(s))
	{
		printf("表达式错误,存在栈为空的情况");
		exit(0);
	}
	//s->TopOfStack--;
	return s->Array[s->TopOfStack--];
}
int JudgeFullStack(Stack s)
{
	return s->TopOfStack + 1 == s->Capacity;
}
void GetInStack(char a, Stack s)
//压入栈
{
	if (JudgeFullStack(s))
	{
		printf("表达式错误,导致出现栈满");
		exit(0);
	}
	s->TopOfStack++;
	s->Array[s->TopOfStack] = a;
}
int main()
{
	int i;
	//创建链表
	Stack s = CreatStack(MaxStackSize);

	char arr[30] = { 0 };
	gets(arr);


	for (i = 0; arr[i] != '\0'; )
	{
		int judg = 0;
		while((arr[i] >= '0' && arr[i] <= '9')||(arr[i]=='.'))
		{
			judg = 1;
			printf("%c", arr[i]);
			i++;
		}
		if(judg==1)
		     printf(" ");
		//如果此时栈顶的元素的优先级比读入的低，则可以进去
		//如果此时栈顶元素的优先级和读入的相等，也应该输出。
		 if (arr[i] == '+'||arr[i]=='-')

		{
			if (JudgeEmpty(s) == 0) {//不为空，则判断是否需要弹出栈
				while (s->Array[s->TopOfStack] != '(')
				{
					char out = GetOutStack(s);
					printf("%c ", out);
					if (JudgeEmpty(s))
					{
						break;
					}
				}
			}
			GetInStack(arr[i], s);//入
			
		}
		else if (arr[i] == '*'||arr[i]=='/')
			//这两个运算符的优先级是相同的
		{
			if (JudgeEmpty(s) == 0) {
				while (s->Array[s->TopOfStack] != '+' &&
			s->Array[s->TopOfStack] != '('&&s->Array[s->TopOfStack]!='-')
				{
					char out = GetOutStack(s);
					printf("%c ", out);
					if (JudgeEmpty(s))
					{
						break;
					}
				}
			}

			GetInStack(arr[i], s);
		}

		else if (arr[i] == '(')
			//无条件入栈。优先级最高
		{
			GetInStack(arr[i], s);
		}

		else if(arr[i]==')')
			 //找到对应的（，并且不用输出
		{
			char out = GetOutStack(s);
			while (out != '(')
			{
				printf("%c ", out);
				out = GetOutStack(s);
			}
		}
		 i++;
	}


	//将栈弹空
	while (JudgeEmpty(s) == 0)
	{
		printf("%c ", GetOutStack(s));
	}

	return 0;
}

不懂就问的乐羽
关注
专栏目录
用Python实现从中序表达式到后序表达式的转换
weixin_43790360的博客
03-04 3229
《Python数据结构与算法分析》（第二版） 中序表达式：( A * B ) + ( C * D ) 后续表达式：A B * C D * + 1. 假设中序表达式是一个以空格分隔的标记串，其中，运算符标记有、/、+和-，括号有(和)，操作数标记有A、B、C等。下面的步骤会生成一个后序标记串。* 创建用于保存运算符的空栈opStack，以及一个用于保存结果的空列表。 使用字符串方法split...
Python - 中序表达式转后序表达式
lq1757442213的博客
03-11 1247
Python实现中序表达式转后序表达式
中序表达式转为后序表达式（c语言）
计算机科学与技术专业学生的成长之路
09-03 4238
按照中序表达式与后序表达式的规则借助堆栈进行表示即可（后附详细链接二叉运算树）） 中序表达式就是我们在数学中见到的中规中矩的表达式，例如3+2-(2*3-7);后序表达式满足运算符号置于数字的后面； 在转化的过程中满足的规则： 若优先级大于栈顶的运算符，那么把它压入栈‘ 若优先级小于等于栈顶的运算符，将堆栈中的所有大于等于它的运算符全部输出，并且将该运算符放入堆栈中； 若各个对象处理完毕，则...
中序表达式转后序表达式
10-22
中序表达式转后序表达式，思路较为清晰，注释详细。。。
中缀表达式
ai309581115的专栏
08-31 1781
原帖：http://www.nowamagic.net/librarys/veda/detail/2307 我们把平时所用的标准四则运算表达式，即“9+(3-1)*3+10/2"叫做中缀表达式。因为所有的运算符号都在两数字的中间，现在我们的问题就是中缀到后缀的转化。 中缀表达式“9+(3-1)*3+10/2”转化为后缀表达式“9 3 1-3*+ 10 2/+” 规
中序表达式转为后序表达式
ikun的博仔的博客
08-02 1642
中序表达式计算以及中序表达式转为后序表达式。
二叉树实现中序表达式转换后序表达式
12-25
原创，用二叉树的非线性结构实现中序表达式转为后序表示的算法，代码简单易懂，解决了用栈来转换的复杂性，及拜托必须用括号来解决操作符优先级的麻烦。
JavaScript中序表达式转后序表达式并计算结果
星星之火 可以燎原
01-17 490
简书地址：https://www.jianshu.com/u/489662a091fd 更多算法 持续更新中… 为什么要转换 中序表达式：10*(8-2*1)*2-30 后序表达式： 10821*-230- 中序表达式是给人看的，可以直观的根据优先级计算出结果，但是计算机无法自动识别优先级，因此将带有计算的优先级和括号的中序表达式变成符合某文法的后序（或前序）表达式之后，计算机可以通过从左到右（...
中序表达式转前序后序
07-08
数据结构的中序表达式转前序，中序转后序，支持负数
用 Python 实现从中序表达式到后序表达式的转换并分析
最新发布
04-03
实现从中序表达式到后序表达式的转换可以使用栈来实现。具体步骤如下： 1. 创建一个空栈和一个空列表，用于存储后序表达式。 2. 从左到右扫描中序表达式的每个字符，如果是数字则添加到后序表达式列表中；如果是...
中序表达式转后序
qq_40622253的博客
07-24 1333
中序表达式转后序表达式的方法 遍历表达式，数字入后序表达式栈； “(”入符号栈 遇到 “)”；则符号栈不断弹出运算符，直到弹出 “)” 遇到运算符，则与符号栈栈顶运算符比较优先级，若栈顶优先级较大，则将栈顶运算符弹出并推入后序栈；否则直接推入符号栈 后序栈弹出并反转即为后序表达式 //方便起见，将后序栈改为后序队列 import java.util.LinkedList; import jav...
将中序表达式转为后序表达式
zhufenghao
10-02 2463
中序表达式：操作运算符在中间，被操作数在操作运算符的两侧的表达式。一般书面上的表达式大多数都是中序表达式，人们看起来直观易懂。 后序表达式：要求操作符出现在其操作数之后。后序表达式易于计算机处理，因为表达式中可以没有括号，而且只需要单向扫描，不再需要考虑运算符的优先级。 举例： 中序表达式： 2*3/(2-1)+3 *(4-1) 后序表达式： 2321-/* 341- *
逆波兰表达式（中序表达式转后序表式式）
axiqia的专栏
01-18 6869
逆波兰表达式（中序表达式转后序表式式）目录:逆波兰表达式中序表达式转后序表式式 简单技巧 算法 测试代码简单技巧：中序表达式转后序表式式： 将中序表达式所有括号补全，然后将所有运算符向右移出无匹配的第一个右括号，去掉括号即为后序表式式举例： 原式：a+b*(c+d/e)补全括号：(a+(b*(c+(d/e))))操作符右移：(a(b(c(de)/)+)*)+去掉括号：abcde/+*+ 中序表达
中序表达式转换成后序表达式问题(栈的应用)
Welcome to oopos's Blog
10-20 3923
/**//*中序表达转换成后序表达式的方法：从左到右读取该中弱序表达式：1.若是操作数，则直接输出.2.若是运算符：(1)若该运算符为"(",则直接入栈.(2)若该运算符为")",则取出堆栈中的运算符，直到"("时.(3)其它： 按优先级比较，如果大于或等于堆栈中当前的运算则压入栈中，否则直接输出.(4)检查栈是否非空，如果非空，则输出所有值，直到空为止.*/#include stdio.h>
中序表达式转为后续表达式
weixin_44022891的博客
08-23 395
中序表达式转为后续表达式,并实现后续表达式的计算 import java.util.ArrayList; import java.util.List; import java.util.Stack; public class InfixToSuffix { public static void main(String[] args) { InfixToSuffix o = new InfixToSuffix(); String s = "(3+4)*5-6";
中序表达式 转为 后序表达式（包含了输出运行的结果）（1310 P102）
hacker_crazy的专栏
08-12 668
中序表达式：我们直观看到的表达式。 中序表达式转前序表达式：就是从右向左历遍表达式，操作数在前，操作符在后的一种形式。 中序表达式转后序表达式：就是从左致右的历遍表达式，操作数在前，操作符在后的一种形式。 参考博客： http://blog.csdn.net/zhufenghao/article/details/48863163 http://www.jiansh
算术表达式的计算：中序表达式转后序表达式
SGT的博客
01-20 5619
算术表达式的计算：中序表达式转后序表达式中序表达式转后序表达式的目的中序表达式转后序表达式后序表达式的计算 中序表达式转后序表达式的目的 在我们的日常数学表达中使用的诸如2*（5-1） 这样的表达式是中序表达式，我们使用数学计算规则对表达式进行计算，但是计算机要计算算术表达式，如果直接使用计算规则（括号-乘除-加减）这样的顺序计算的话就要去使用if-else语句判断括号、加减乘除然后计算，如果一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值