2024年大数据最新数据结构 后缀表达式【深入剖析堆栈原理】_后缀表达式原理，2024年最新你们觉得作为一名程序员最大的悲哀是什么

于 2024-05-05 13:47:16 发布
阅读量934 收藏 13
点赞数 26
分类专栏： 程序员 文章标签： 大数据 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84615578/article/details/138465274
版权

img
img
img

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

需要这份系统化资料的朋友，可以戳这里获取

Part2
【5 + 8*2 + ( 3 * 9 + 6 )*4】

  • 读到【+】，这时要注意，引起优先级低于【*】，所以乘号出栈，放入表达式，但此时遍历到的操作符op与栈中的【+】一致，故栈中的【+】也因放入表达式，接着将遍历到的【+】入栈

在这里插入图片描述

Part3
【5 + 8*2 + ( 3 * 9 + 6 )*4】

  • 首先读到左括号【(】，这代表一个子表达式的开始，因其优先级最高，故直接入栈
  • 然后是3，根据法则二，直接放入表达式
  • 接着遇到【*】，此时要注意，根据法则六，因为还没有碰到右括号【)】，说明子表达式还没结束，故直接入栈
  • 最后是9，同理，放入表达式

在这里插入图片描述

Part4
【5 + 8*2 + ( 3 * 9 + 6 )*4】

  • 首先我们遇到【+】，这是看到栈顶op为【*】，比其低，根据法则三，弹出栈顶元素，并将当前op入栈
  • 然后是6，根据法则二，直接放入表达式
  • 最后读到【)】，表示子表达式结束，开始逐个弹出栈顶元素，直到左括号【(】弹出后结束（括号均不放入表达式）

在这里插入图片描述

Part5
【5 + 8*2 + ( 3 * 9 + 6 )*4】

  • 碰到【*】，因其优先级高于栈中的【+】，故直接入栈
  • 然后是4，根据法则二，直接放入表达式

在这里插入图片描述

Part6
【5 + 8*2 + ( 3 * 9 + 6 )*4】

  • 最后遍历到末尾，栈中还有两个操作符op，直接弹出即可（不放入表示式）

在这里插入图片描述

  • 最后的postexp即为转换后的后缀表达式【582*+39*6+4】

🌳手撕代码【不信你看不懂】

了解了堆栈的基本原理后，接下来就是代码环节，也是可视化计算的重要一趴

void trans(char\* exp, char postexp[])	//将算术表达式exp转换成后缀表达式postexp
{
	char e;
	SqStack\* Optr;						//定义运算符栈
	InitStack(Optr);					//初始化运算符栈
	int i = 0;							//i作为postexp的下标
	while (\*exp != '\0')					//exp表达式未扫描完时循环
	{
		switch (\*exp)
		{
		case '(':						//判定为左括号
			Push(Optr, '(');				//左括号进栈
			exp++;						//继续扫描其他字符
			break;
		case ')':						//判定为右括号
			Pop(Optr, e);				//出栈元素e
			while (e != '(')				//不为'('时循环
			{
				postexp[i++] = e;			//将e存放到postexp中
				Pop(Optr, e);			//继续出栈元素e
			}
			exp++;						//继续扫描其他字符
			break;
		case '+':						//判定为加或减号
		case '-':
			while (!StackEmpty(Optr))	//栈不空循环
			{
				GetTop(Optr, e);			//取栈顶元素e
				if (e != '(')				//e不是'('
				{
					postexp[i++] = e;		//将e存放到postexp中
					Pop(Optr, e);		//出栈元素e
				}
				else					//e是'(时退出循环
					break;
			}
			Push(Optr, \*exp);			//将'+'或'-'进栈
			exp++;						//继续扫描其他字符
			break;
		case '\*':						//判定为'\*'或'/'号
		case '/':
			while (!StackEmpty(Optr))	//栈不空循环
			{
				GetTop(Optr, e);			//取栈顶元素e
				if (e == '\*' || e == '/')	//将栈顶'\*'或'/'运算符出栈并存放到postexp中
				{
					postexp[i++] = e;		//将e存放到postexp中
					Pop(Optr, e);		//出栈元素e
				}
				else					//e为非'\*'或'/'运算符时退出循环
					break;
			}
			Push(Optr, \*exp);			//将'\*'或'/'进栈
			exp++;						//继续扫描其他字符
			break;
		default:				//处理数字字符
			while (\*exp >= '0' && \*exp <= '9') //判定为数字
			{
				postexp[i++] = \*exp;
				exp++;
			}
			postexp[i++] = ' ';	//用#标识一个数值串结束
		}
	}
	while (!StackEmpty(Optr))	//此时exp扫描完毕,栈不空时循环
	{
		Pop(Optr, e);			//出栈元素e
		postexp[i++] = e;			//将e存放到postexp中
	}
	postexp[i] = '\0';			//给postexp表达式添加结束标识
	DestroyStack(Optr);			//销毁栈 
}

看完这串代码，不用猜，我知道你已经已经想点下浏览器中这个网页的【×】了。但是何妨不听我讲完再说

  • 这里我们需要用到顺序的结构实现原理SqStack，代码在最后给出，这里就展示转换的算法部分
  • 整体浏览，这串代码处于一个while循环之中，也就是对给出的字符串进行的一个遍历，【!= ‘\0’】在C语言中表示还没到字符串结尾
  • 在大层的while循环之下是一个switch()分支判断，判断的就是当前所遍历的exp，在英文中是expression【表达式】，上面讲到的postexp就是postexpression【后缀表达式】，我们的目的就是要去exp中遍历每一个字符，然后将符合条件的字符按照后缀表达式的法则以及堆栈的原理一个个地放入postexp中，然后我们来分别说说每个case的判断
  • 首先是左括号【(】，这个直接进栈即可，exp++表示将遍历下一个字符，break表示的跳出当前的case分支，若是不写这一句，则程序会一直往下走，直到下一个break才会跳出
case '(':						//判定为左括号
	Push(Optr, '(');				//左括号进栈
	exp++;						//继续扫描其他字符
	break;
  • 接着是右括号【)】，上面说过了，若是碰到右括号，则开始出栈栈顶元素，知道栈顶元素为左括号【(】时，while体中的语句就是将当前出栈的元素放入postexp后缀表达式中，i++表示为下一个位置留出位置，然后Pop出栈即可，循环结束后继续扫描下一个字符
case ')':						//判定为右括号
	Pop(Optr, e);				//出栈元素e
	while (e != '(')				//不为'('时循环
	{
		postexp[i++] = e;			//将e存放到postexp中
		Pop(Optr, e);			//继续出栈元素e
	}
	exp++;						//继续扫描其他字符
	break;
  • 然后是【+】【-】，它们的循环条件是栈不为空，首先去获取栈顶元素，若获取的元素不为左括号【(】，则表示子表达式没结束，不停地将栈顶元素放入postexp中，然后出栈。若是碰到了左括号【(】，则跳出当前循环，循环后将当前的【+】【-】入栈，继续扫描下一个字符
case '+':						//判定为加或减号
case '-':
	while (!StackEmpty(Optr))	//栈不空循环
	{
		GetTop(Optr, e);			//取栈顶元素e
		if (e != '(')				//e不是'('
		{
			postexp[i++] = e;		//将e存放到postexp中
			Pop(Optr, e);		//出栈元素e
		}
		else					//e是'(时退出循环
			break;
	}
	Push(Optr, \*exp);			//将'+'或'-'进栈
	exp++;						//继续扫描其他字符
	break;
  • 其次就是【*】【/】，同样，也是在栈不空时循环，获取到栈顶元素，若是碰到相同的乘号或除号，则将它们放入postexp中，若是没有，则跳出循环，直接将它们放入栈中即可
case '\*':						//判定为'\*'或'/'号
case '/':
	while (!StackEmpty(Optr))	//栈不空循环
	{
		GetTop(Optr, e);			//取栈顶元素e
		if (e == '\*' || e == '/')	//将栈顶'\*'或'/'运算符出栈并存放到postexp中
		{
			postexp[i++] = e;		//将e存放到postexp中
			Pop(Optr, e);		//出栈元素e
		}
		else					//e为非'\*'或'/'运算符时退出循环
			break;
	}
	Push(Optr, \*exp);			//将'\*'或'/'进栈
	exp++;						//继续扫描其他字符
	break;
  • 最后就是另外的数字情况的判断，若为数字字符，直接将其放入postexp中即可，然后在每个数字后加一个空格来进行标识
default:				//处理数字字符
	while (\*exp >= '0' && \*exp <= '9') //判定为数字
	{
		postexp[i++] = \*exp;
		exp++;
	}
	postexp[i++] = ' ';	//用空格标识一个数值串结束
  • 最后面的这段就是处理最后栈中还剩余的元素，将其依次出栈放入postexp即可，直到栈为空为止，最后别忘了postexp也是一个字符串，既然是字符串最后就要手动加上’\0’，就是尾插法最后要的r - >next = NULL是一个道理
while (!StackEmpty(Optr))	//此时exp扫描完毕,栈不空时循环
{
	Pop(Optr, e);			//出栈元素e
	postexp[i++] = e;			//将e存放到postexp中
}
postexp[i] = '\0';			//给postexp表达式添加结束标识
DestroyStack(Optr);			//销毁栈

看完了上面的细致讲解，难道你还想退出吗，不想的话就继续跟着我来吧🚶

✒闭隐：如何对后缀表达式进行求值？【⭐⭐⭐】

将中缀表达式转换为后缀表达式后，只是完成了我们的第一步，也就是有了一个模型了，接下去就要将其细心雕刻直至完美🍁

  • 对后缀表达式的求值并不是很难，但是也需要涉及到堆栈FILO的原理，这需要你对Stack非常得熟悉
  • 这里的顺序栈数据结构体的数据类型要记得换一下，不可以用char了，前面我们是在遍历字符，所以用char，但是这里是要去求值，但是数字可能会是小数，所以最好声明成double类型，这个不难，只需要改一下各个数据类型即可

🌳运算规则

首先一样，我们要了解一下其运算规则

  • 后缀表达式求值的算法是遍历后缀表达式，如果遇到运算数，那么运算数入栈
  • 如果遇到运算符，那么弹出栈里面两个元素，先弹出的是右运算数，后弹出的是左运算数，计算运算结果，然后将结果入栈。最后遍历到后缀表达式末尾，当结果只有一个元素时，就是答案
double compvalue(char\* postexp)	//计算后缀表达式的值
{
	double d, a, b, c, e;
	SqStack1\* Opnd;				//定义操作数栈
	InitStack1(Opnd);			//初始化操作数栈
	while (\*postexp != '\0')		//postexp字符串未扫描完时循环
	{
		switch (\*postexp)
		{
		case '+':				//判定为'+'号
			Pop1(Opnd, a);		//出栈元素a
			Pop1(Opnd, b);		//出栈元素b
			c = b + a;				//计算c
			Push1(Opnd, c);		//将计算结果c进栈
			break;
		case '-':				//判定为'-'号
			Pop1(Opnd, a);		//出栈元素a
			Pop1(Opnd, b);		//出栈元素b
			c = b - a;				//计算c
			Push1(Opnd, c);		//将计算结果c进栈
			break;
		case '\*':				//判定为'\*'号
			Pop1(Opnd, a);		//出栈元素a
			Pop1(Opnd, b);		//出栈元素b
			c = b \* a;				//计算c
			Push1(Opnd, c);		//将计算结果c进栈
			break;
		case '/':				//判定为'/'号
			Pop1(Opnd, a);		//出栈元素a
			Pop1(Opnd, b);		//出栈元素b
			if (a != 0)
			{
				c = b / a;			//计算c
				Push1(Opnd, c);	//将计算结果c进栈
				break;
			}
			else
			{
				printf("\n\t除零错误!\n");
				exit(0);		//异常退出
			}
			break;
		default:				//处理数字字符
			d = 0;				//将连续的数字字符转换成对应的数值存放到d中
			while (\*postexp >= '0' && \*postexp <= '9')   //判定为数字字符
			{
				d = 10 \* d + \*postexp - '0';
				postexp++;
			}
			Push1(Opnd, d);		//将数值d进栈

			break;
		}
		postexp++;				//继续处理其他字符
	}
	GetTop1(Opnd, e);			//取栈顶元素e
	DestroyStack1(Opnd);		//销毁栈 
	return e;					//返回e
}

🌳关键代码讲解

  • 这里主要是讲讲解一下如何去运算，看到【default】分支，当后缀表达式碰到数字字符的时候，这里需要将其转换为数字，也就是 - ‘0’，因为’0’的ASCLL码值为48。假设一个数为1,1的ASCLL码值为49，那么49-48也就是1
  • 主要还是来解释一下为什么d 要乘10，大家可以看到，这是一个while循环，因为这是一个不断在找数字的过程，若是在遍历到数字字符后又遍历到了一个，那要如何运算呢，*10就代表着上一个数字要为十位，而当前遍历数字在转换为数字后是为个位，将遍历到的所有数字字符转换后进行一个相加，最后当遍历到的不是数字字符时，才将此相加完的数放入栈中，然后退出循环去处理下一个字符

👀观镜：结果测试

🌳测试结果展示

首先，就是要在main函数中，传入对应的exp和postexp

  • 尤其是对于这个exp，大家千万不要留空格，否则在中缀转后缀的时候就会出现数组越界异常
  • 也就是因为这几个空格，我调试了一个下午😄
char exp[] = "(56 - 20)/(4 + 2)";	//错误！！！
char exp[] = "(56-20)/(4+2)";		//正确！！！


char exp[] = "5+8\*2+(3\*9+6)\*4";
char postexp[MaxSize];
trans(exp, postexp);

printf("中缀表达式为：%s\n", exp);
printf("后缀表达式为：%s\n", postexp);
printf("表达式的值为：%g\n", compvalue(postexp));

这就是最终的结果，看后缀表达式，和我们上面通过堆栈原理分析的完全吻合，大家算出来是这样吗😃

在这里插入图片描述

🌳整体代码展示

//求简单表达式的值
#include <stdio.h>
#include <stdlib.h>
#define MaxSize 100
//---------------------------------------------------------
//--运算符栈基本运算---------------------------------------
//---------------------------------------------------------
typedef struct
{
	char data[MaxSize];			//存放运算符
	int top;					//栈顶指针
} SqStack;
void InitStack(SqStack\*& s)		//初始化栈
{
	s = (SqStack\*)malloc(sizeof(SqStack));
	s->top = -1;
}
void DestroyStack(SqStack\*& s)	//销毁栈
{
	free(s);
}
bool StackEmpty(SqStack\* s)		//判断栈是否为空
{
	return(s->top == -1);
}
bool Push(SqStack\*& s, char e)	//进栈元素e
{
	if (s->top == MaxSize - 1)
		return false;
	s->top++;
	s->data[s->top] = e;
	return true;
}
bool Pop(SqStack\*& s, char& e)	//出栈元素e
{
	if (s->top == -1)
		return false;
	e = s->data[s->top];
	s->top--;
	return true;
}
bool GetTop(SqStack\* s, char& e)	//取栈顶元素e
{
	if (s->top == -1)
		return false;
	e = s->data[s->top];
	return true;
}
//---------------------------------------------------------

void trans(char\* exp, char postexp[])	//将算术表达式exp转换成后缀表达式postexp
{
	char e;
	SqStack\* Optr;						//定义运算符栈
	InitStack(Optr);					//初始化运算符栈
	int i = 0;							//i作为postexp的下标
	while (\*exp != '\0')					//exp表达式未扫描完时循环
	{
		switch (\*exp)
		{
		case '(':						//判定为左括号
			Push(Optr, '(');				//左括号进栈
			exp++;						//继续扫描其他字符
			break;
		case ')':						//判定为右括号
			Pop(Optr, e);				//出栈元素e
			while (e != '(')				//不为'('时循环
			{
				postexp[i++] = e;			//将e存放到postexp中
				Pop(Optr, e);			//继续出栈元素e
			}
			exp++;						//继续扫描其他字符
			break;
		case '+':						//判定为加或减号
		case '-':
			while (!StackEmpty(Optr))	//栈不空循环
			{
				GetTop(Optr, e);			//取栈顶元素e
				if (e != '(')				//e不是'('
				{
					postexp[i++] = e;		//将e存放到postexp中
					Pop(Optr, e);		//出栈元素e
				}
				else					//e是'(时退出循环
					break;
			}
			Push(Optr, \*exp);			//将'+'或'-'进栈
			exp++;						//继续扫描其他字符
			break;
		case '\*':						//判定为'\*'或'/'号
		case '/':
			while (!StackEmpty(Optr))	//栈不空循环
			{
				GetTop(Optr, e);			//取栈顶元素e
				if (e == '\*' || e == '/')	//将栈顶'\*'或'/'运算符出栈并存放到postexp中
				{
					postexp[i++] = e;		//将e存放到postexp中
					Pop(Optr, e);		//出栈元素e
				}
				else					//e为非'\*'或'/'运算符时退出循环
					break;
			}
			Push(Optr, \*exp);			//将'\*'或'/'进栈
			exp++;						//继续扫描其他字符
			break;
		default:				//处理数字字符
			while (\*exp >= '0' && \*exp <= '9') //判定为数字
			{
				postexp[i++] = \*exp;
				exp++;
			}
			postexp[i++] = ' ';	//用空格标识一个数值串结束
		}
	}
	while (!StackEmpty(Optr))	//此时exp扫描完毕,栈不空时循环
	{
		Pop(Optr, e);			//出栈元素e
		postexp[i++] = e;			//将e存放到postexp中
	}
	postexp[i] = '\0';			//给postexp表达式添加结束标识
	DestroyStack(Optr);			//销毁栈 
}
//---------------------------------------------------------
//--操作数栈基本运算---------------------------------------
//---------------------------------------------------------
typedef struct
{
	double data[MaxSize];			//存放数值
	int top;						//栈顶指针
} SqStack1;
void InitStack1(SqStack1\*& s)		//初始化栈
{
	s = (SqStack1\*)malloc(sizeof(SqStack1));
	s->top = -1;
}
void DestroyStack1(SqStack1\*& s)	//销毁栈
{


![img](https://img-blog.csdnimg.cn/img_convert/1da8ec9b5ee5d8a24423b77cbed31850.png)
![img](https://img-blog.csdnimg.cn/img_convert/23838b10bfb429aaadcbfd50ce36ff4a.png)
![img](https://img-blog.csdnimg.cn/img_convert/da2215c89223bd114bdf8d82f4bc6494.png)

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**

**[需要这份系统化资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618545628)**

--------------------------------------------------------
typedef struct
{
	double data[MaxSize];			//存放数值
	int top;						//栈顶指针
} SqStack1;
void InitStack1(SqStack1\*& s)		//初始化栈
{
	s = (SqStack1\*)malloc(sizeof(SqStack1));
	s->top = -1;
}
void DestroyStack1(SqStack1\*& s)	//销毁栈
{


[外链图片转存中...(img-lMFX2nFf-1714887985556)]
[外链图片转存中...(img-5Zt3M6Oh-1714887985556)]
[外链图片转存中...(img-j8WKTfN1-1714887985557)]

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**

**[需要这份系统化资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618545628)**
2401_84615578
关注
专栏目录
【算法】逆波兰式（后缀表达式）的计算 & 中缀表达式转后缀表达式（逆波兰式）
九师兄
10-24 2030
【算法】逆波兰式（后缀表达式）的计算 & 中缀表达式转后缀表达式（逆波兰式）
对栈的学习（前缀、中缀、后缀表达式）超详细！由计算器的实现哦
zhao_to的博客
05-21 512
栈 栈的概念 1)栈的英文为(stack) 2)栈是一个先入后出(FILO-First In Last Out)的有序列表。 3)栈(stack)是限制线 性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶（Top)，另中一端为固定的一 端，称为栈底(Bottom)。 4)根据栈的走义可知，最先放入栈中元素在栈底，最后放入的元素在栈项，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除 栈的应用场景 1)子程序的调用:在跳往子程序前，
数据结构（中缀表达式转后缀表达式）
04-25
/*程序由本人编译，并且经过多次测试，正确无误！目前该转换算法只支持数字在0至9之间的+-*/四元运算转换.*/ /**************程序员信息 ***************东北大学*******************东大很厉害**************** ***************软件学院*******************软件学院更厉害************ ***************08级软件工程***************想了解东大吗?************* ***************www.neu.edu.cn*************************************** ***************个人主页：http://hi.baidu.com/stillrain************** */
数据结构 | 后缀表达式【深入剖析堆栈原理】
做技术人 · 产优质博客 · 找好工作
10-02 4573
数据结构之堆栈的应用中的后缀表达式讲解，层层递进，由浅入深，带你深刻理解后缀表达式
中缀表达式变成等价的后缀表达式的算法
wxm3373477的博客
01-19 828
理论： （这部分很重要，看明白了，可以写出实现算法） 表达式的表示形式有中缀、前缀和后缀3中形式。中缀表达式按操作符的优先级进行计算（后面代码实现只包括+、-、*、\,小括号），即数学运算。 后缀表达式中只有操作数和操作符。操作符在两个操作数之后。它的计算规则非常简单，严格按照从左到右的次序依次执行每一个操作。每遇到一个操作符，就将前面的两个数执行相应的操作。 由后缀表达式计算中缀表达...
栈之后缀表达式
weixin_34355559的博客
02-06 489
一、后缀表达式介绍 后缀表达式的特点就是计算机运算非常方便，需要用到栈；计算机处理过程只需要顺序读入，如果遇到数字，则放入栈中，如果是运算符，则将两个栈中数字取出进行运算； 比如1+2的后缀表达式为12+; 而栈可以把一般的中缀表达式变成后缀表达式，并且计算后缀表达式得出结果，因此此应用在计算器中非常常用； 二、中缀表达式转换成后缀表达式 此方法需要遵循几个规则： (...
后缀数据结构
weixin_30949361的博客
03-15 192
后缀自动机 参考 http://blog.sina.com.cn/s/blog_70811e1a01014dkz.html http://blog.csdn.net/cyendra/article/details/37993603?utm_source=tuicool "一个构造好的 SAM 实际上包含了两个图：由 go 数组组成的 DAG 图;由 par 指针构成的 parent...
C语言 数据结构 stack实现计算器 中缀表达式 后缀表达式
星云
10-24 1113
下面这个能按照运算顺序计算和支持带括号的运算，还输出后缀表达式。## 调用关系 ```mermaid graph LR A[main] B[Scanner] C[Build] D[help] E[NaturalCut] F[IsObjector] G[NowCalculate] H[IsPartOfNumber] I[Calculate] J[InLevel] K[new_dBrick] L[new_sBrick] M[CreateStack] N[Push] O[Pop] P[isEmpty] L---C
精选_基于C++实现的表达式计算_源码打包
03-06
7. **堆栈（Stack）**: 堆栈数据结构在表达式计算中起到关键作用，特别是在后缀表达式（也称逆波兰表示法）的计算中。通过将运算符压入堆栈，可以按照后缀表达式规则进行计算，避免了优先级和括号的问题。 8. **...
数据结构 约瑟夫环 表达式求值 括号比配
05-11
综上所述，这个压缩包提供的程序可以作为学习数据结构的实例，帮助我们理解和应用约瑟夫环、表达式求值和括号匹配等经典算法，同时也包含了行编辑这一实用技能的实践，以及源代码的阅读和分析，对于提升编程能力具有...
后缀表达式（栈）
weixin_51671868的博客
09-05 451
用栈完成后缀表达式的计算。
【后缀表达式——栈】
m0_51506743的博客
04-06 1062
简化的后缀表达式🍜
后缀表达式与栈
LyTsai的专栏
04-02 1642
/* *stack，操作受限制的线性表，在表的一端进行插入和删除，先进后出（FILO），后进先出（LIFO）。表尾是栈顶（top)，表头是栈底（bottom)。 *top不是指针类型，但习惯称为栈顶指针，习惯用词还有push和pop表示入栈和出栈 *栈空，top是-1（数组）或者0，看是怎么约定的，这里采用栈空指向0 *例子采用C++，文档后缀cpp，struct关键词省略 *至于栈的链
[LeetCode]150. 逆波兰表达式求值
张小猪的家
08-28 789
150. 逆波兰表达式求值 难度：中等 根据 逆波兰表示法，求表达式的值。 有效的算符包括 +、-、*、/ 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。 说明： 整数除法只保留整数部分。 给定逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。 示例 1： 输入：tokens = ["2","1","+","3","*"] 输出：9 解释：该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9 示例 2： 输入：tokens = ["4","1
栈的应用：后缀表达式
weixin_45916890的博客
02-12 613
数据结构 Java语言描述
栈的应用 ---后缀表达式
小博客
04-11 1704
后缀表达式定义：不包含括号，运算符放在两个运算对象的后面，所有的计算按运算符出现的顺序，严格从左向右进行（不再考虑运算符的优先规则，如：(2 + 1) * 3 ， 即2 1 + 3 *举个例子：后缀表达式：9 3 1-3*+ 10 2/+后缀表达式规则：从左到右遍历表达式的每个数字和符号，遇到是数字就进栈，遇到是符号，就将处于栈顶两个数字出栈，进行运算，运算结果进栈，一直到最终获得结果。下面是详细的
后缀表达式的理解——数据结构入门——栈
weixin_47336748的博客
01-28 673
平时我们写的表达式是中缀表达式9+(3-1)*3+10/2，形如9 3 1-3 * + 10 2 / +叫做后缀表达式。 如何看懂后缀表达式？ 遍历中缀表达式，遇到数字就输出，遇到符号就入栈。 遇到右括号时，栈中必有左括号，把两括号之间的运算符输出。 若要入栈的符号“+”优先级低于栈顶符号的优先级，栈中元素全部出栈，“+”号再入栈。 到最后，所有元素依次出栈（先进后出的次序）。 ...
后缀表达式
Cipher的博客
10-18 460
题目描述 所谓后缀表达式是指这样的一个表达式：式中不再引用括号，运算符号放在两个运算对象之后，所有计算按运算符号出现的顺序，严格地由左而右新进行（不用考虑运算符的优先级）。 如：3*(5–2)+7对应的后缀表达式为：3．5．2．-*7．+@。’@’为表达式的结束符号。‘.’为操作数的结束符号。 输入格式 输入：后缀表达式 输出格式 输出：表达式的值 代码如下： #include<bits/stdc++.h> using namespace std; char c[5]; int main().
后缀表达式----栈
1900的博客
04-02 581
Input 若干行，每行对应一个中缀表达式 Output 若干行，每行对应一个由中缀表达式转换而来的后缀表达式 Sample Input X+A*(Y-B)-Z/F A+B*C+(D*M-N)+(S-T)*Y A-B*C+(D-E*F)/G Sample Output XAYB-*+ZF/- ABC*+DM*N-+ST-Y*+ ABC*-DEF*-G/+ 解题思路:...
哈工大数据结构实验：中缀转后缀表达式求值
"哈尔滨工业大学计算机科学与技术学院的数据结构与算法实验，...实验通过这种方式让学生深入理解栈数据结构的应用，以及如何使用算符优先法解决表达式求值问题，这在编译原理、算法设计和计算理论等领域都有重要应用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值