数据结构 | 后缀表达式【深入剖析堆栈原理】

这篇具有很好参考价值的文章主要介绍了数据结构 | 后缀表达式【深入剖析堆栈原理】。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

数据结构 | 后缀表达式【深入剖析堆栈原理】

Hello,大家好,国庆的第二天,带来的是数据结构中堆栈部分的后缀表达式,这也是一块有关栈的应用方面困扰了众多同学的一个大难题,今天就让我们一起解决这个难题📕

❓初见:什么是后缀表达式

后缀表达式也称为逆波兰表达式,也就是将算术运算符放在操作数的后面

  • 例如【1 + 2 * 3】的后缀表达式形式变为【1 2 3 * +】,前面的那个叫做中缀表达式,也就是我们最常用的,遵循的规则是“先乘除,后加减”
  • 那有些小伙伴就很疑惑,为什么要这么去做呢,好好地用我门正常的计算形式去运算不就好了,下面我们就来讲讲后缀表达式

后缀表达式的优势

  • 对于后缀表达式,它十分地有用,因为其可以把复杂的表达式转化为依靠简单操作得到的计算结果的表达式。就我们上面这个表达式来看,是非常简单的,但如果换一个复杂一些的呢,你能够在短期时间内把它计算出来吗👇

数据结构 | 后缀表达式【深入剖析堆栈原理】

  • 可以看出,对于这个中缀表达式,是比较复杂的,但是我们利用后缀表达式去简化,看起来就没有这么复杂了,利用这个表达式与堆栈的先进后出【FILO】原理,就可以达到事半而功倍的效果

🗡磨砺:怎样将中缀表达式转换为后缀表达式【⭐⭐⭐⭐⭐】

相信这部分是大家最难过的一道坎,让我们来一探究竟🔍

🌳熟悉规则【重点基础掌握】

首先,最重要的一点是你必须知道转换的规则

📚法则一:如果遇到一个运算符op以及左括号“(”,此时栈如果为空,则直接将其进栈
📚法则二:若是遇到了操作数num,就将其直接输出
📚法则三:如果栈不为空,则只有当op的优先级高于栈顶运算符优先级时才将其进栈,否则将栈顶op弹出
📚法则四:若当前op进栈时发现栈中有与之相同op,则出栈其一,再加当前op压入栈中
📚法则五:若遇到右括号,则开始弹出栈字符,直到左括号为止
📚法则六:只要当遇到右括号“)”时,才从栈中弹出左括号“(”,否则一直遍历

  • 以上法则是我们要了解后缀表达式转换的基本,你必须将其记牢

🌳层层剖析【堆栈原理展示】

有了固定的发展,接下来就是具体的案例和分析

  • 我们以此表达式为例进行讲解【5 + 8*2 + ( 3 * 9 + 6 )*4】

Part1

  • 首先是5,根据法则二,直接放入表达式
  • 然后是操作符【+】,根据法则一,栈为空,直接入栈
  • 接着是8,同理,直接放入表达式
  • 其次是操作符【*】,因优先级高于【+】,故直接入栈
  • 最后又碰到一个2,同理,直接放入表达式

数据结构 | 后缀表达式【深入剖析堆栈原理】


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)	//销毁栈
{
	free(s);
}
bool StackEmpty1(SqStack1* s)		//判断栈是否为空
{
	return(s->top == -1);
}
bool Push1(SqStack1*& s, double e)	//进栈元素e
{
	if (s->top == MaxSize - 1)
		return false;
	s->top++;
	s->data[s->top] = e;
	return true;
}
bool Pop1(SqStack1*& s, double& e)	//出栈元素e
{
	if (s->top == -1)
		return false;
	e = s->data[s->top];
	s->top--;
	return true;
}
bool GetTop1(SqStack1* s, double& e)	//取栈顶元素e
{
	if (s->top == -1)
		return false;
	e = s->data[s->top];
	return true;
}
//---------------------------------------------------------

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
}
void test()
{
	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));
	
}

int main(void)
{
	test();
	return 0;
}

🛡开战:实战演练【LeetCode习题深入】

明白了如何将一个中缀表达式转换为后缀表达式,并且清楚了如何求值。接下来让我们到力扣上去找道题去练练手吧

原题传送门——逆波兰表达式求值

🌳题目描述

根据 逆波兰表示法,求表达式的值。

有效的算符包括 +、-、*、/ 。每个运算对象可以是整数,也可以是另一个逆波兰表达式。

注意 两个整数之间的除法只保留整数部分。

可以保证给定的逆波兰表达式总是有效的。换句话说,表达式总会得出有效数值且不存在除数为 0 的情况。

示例 1:

输入:tokens = [“2”,“1”,“+”,“3”,“*”]
输出:9
解释:该算式转化为常见的中缀算术表达式为:((2 + 1) * 3) = 9

示例 2:

输入:tokens = [“4”,“13”,“5”,“/”,“+”]
输出:6
解释:该算式转化为常见的中缀算术表达式为:(4 + (13 / 5)) = 6

示例 3:

输入:tokens = [“10”,“6”,“9”,“3”,“+”,“-11”,““,”/“,””,“17”,“+”,“5”,“+”]
输出:22
解释:该算式转化为常见的中缀算术表达式为:
((10 * (6 / ((9 + 3) * -11))) + 17) + 5
= ((10 * (6 / (12 * -11))) + 17) + 5
= ((10 * (6 / -132)) + 17) + 5
= ((10 * 0) + 17) + 5
= (0 + 17) + 5
= 17 + 5
= 22

🌳思路分析

  • 首先对于逆波兰表达式,它其实和二叉树的后续遍历挺像的, 大家可以把运算符作为中间节点,按照后序遍历的规则画出一个二叉树。
  • 我们已经了解了它的运算规则,题目已经是一个后缀表达式,所以我们不需要进行繁琐的转换,只要对给出的字符串进行一个遍历,看它是数字还是加减乘除运算符即可

🌳动画展示

温馨提示,微信手机端看不到

逆波兰表达式

🌳整体代码展示

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<int> st;
        for(int i = 0;i < tokens.size(); ++i)
        {
            if(tokens[i] == "+" || tokens[i] == "-" || tokens[i] == "*" || tokens[i] == "/")
            {
                int num1 = st.top();    st.pop();
                int num2 = st.top();    st.pop();

                if(tokens[i] == "+")    st.push(num2 + num1);
                if(tokens[i] == "-")    st.push(num2 - num1);
                if(tokens[i] == "*")    st.push((long long)num2 * num1);
                if(tokens[i] == "/")    st.push(num2 / num1);
            }
            else
            {
                //若为数字字符,则将其转换为数字,方便后续运算
                st.push(stoi(tokens[i]));   
            }
        }
        int ret = st.top();
        st.pop();
        return ret;
    }
};

🌳重点讲解

  • 代码很简单,就是去遍历给出的这个字符串,判断其为加减乘数四个运算符,是的话就将栈中的头两个元素出栈,进行一个四则运算,但是这里要注意的是因为展示FILO,

  • 你第一个进栈的,也就是第二个出栈的才是第一个操作符

  • 你第二个进栈的,也就是你第一个出栈的是第二个操作符

  • 这个逻辑一定要理清,否则会出现运算问题,可以看到这里的运算num2都是在num1的前面

  • 若不是四个运算符,则将其转换为数字进栈即可,这里用到了一个比较偏僻的函数stoi(),它可以将一个字符转换为数字形式,大家不清楚的可以去了解一下

🤔归思:总结与提炼

OK,这就是我们今天要讲解的内容,有关数据结构中堆栈应用方面——后缀表达式,你学废了吗🎓文章来源地址https://www.toymoban.com/news/detail-426760.html

到了这里,关于数据结构 | 后缀表达式【深入剖析堆栈原理】的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【数据结构】超详细讲解:算术表达式转化为后缀表达式、前缀表达式、表达式树的构建

    作者: 努力学习的大一在校计算机专业学生,热爱学习和创作。目前在学习和分享:算法、数据结构、Java等相关知识。 博主主页: @是瑶瑶子啦 所属专栏: 【数据结构】:该专栏专注于数据结构知识,持续更新,每一篇内容优质,浅显易懂,不失深度! 近期目标: 写好专栏

    2024年02月08日
    浏览(53)
  • 数据结构——前缀、中缀、后缀表达式实现和转换(Java)

    1.7.1 概念 它们都是对表达式的记法,因此也被称为前缀记法、中缀记法和后缀记法。它们之间的区别在于 运算符相对与操作数的位置 不同 前缀 表达式的运算符位于与其相关的 操作数之前 ;中缀和后缀同理。 平时我们 日常使用 并最为熟悉的就是中缀表达式。如: 1 + 2 *

    2024年02月05日
    浏览(55)
  • 【尚硅谷】数据结构和算法——前缀、中缀、后缀表达式规则

    跟着B站的尚硅谷学习数据结构与算法,语言为java,目前是第七个代码内容——前缀、中缀、后缀表达式 课程传送门:尚硅谷——前缀、中缀、后缀表达式 1)前缀表达式又称波兰式, 前缀表达式 的运算符位于操作符之前。 2)举例说明:(3+4)*5-6 对应的前缀表达式就是 - *

    2024年02月03日
    浏览(59)
  • 【数据结构】一篇文章带你彻底学会《后缀表达式》

    创作不易,本篇文章如果帮助到了你,还请点赞 关注支持一下♡𖥦)!! 主页专栏有更多知识,如有疑问欢迎大家指正讨论,共同进步! 🔥c语言系列专栏:c语言之路重点知识整合 🔥 给大家跳段街舞感谢支持!ጿ ኈ ቼ ዽ ጿ ኈ ቼ ዽ ጿ ኈ ቼ ዽ ጿ ኈ ቼ ዽ ጿ ኈ ቼ 后缀表

    2024年02月05日
    浏览(57)
  • 数据结构与算法-(7)---栈的应用-(4)后缀表达式求值

    🌈write in front🌈 🧸大家好,我是Aileen🧸.希望你看完之后,能对你有所帮助,不足请指正!共同学习交流. 🆔本文由Aileen_0v0🧸 原创 CSDN首发🐒 如需转载还请通知⚠️ 📝个人主页:Aileen_0v0🧸—CSDN博客 🎁欢迎各位→点赞👍 + 收藏⭐️ + 留言📝​ 📣系列专栏:Aileen_0v0🧸

    2024年02月07日
    浏览(52)
  • 【夜深人静学数据结构与算法 | 第二篇】后缀(逆波兰)表达式

    目录 前言:  中缀表达式:  后缀表达式: 中缀表达式转后缀表达式: 后缀表达式计算结果: 总结:  计算机在计算四则运算的时候,由于括号以及运算优先级的存在,并不能够很好的处理所有的运算,为了处理这种情况,我们引入了后缀表达式来优化算法。         

    2024年02月13日
    浏览(58)
  • 数据结构之表达式求值

     前言 运用堆栈解决表达式的求值,代码思路为: 1.定义两个栈,一个char类型的栈用于存放运算符(ysf)一个int类型的栈用于存放操作数(czs) 如一个表达式3+6*9,将“+”,“*”入ysf栈,将“3”“6”“9”入czs栈 2.运用getchar进行数据的录入,如果接收的是运算符,将其插入到运

    2024年04月29日
    浏览(35)
  • Java LeetCode篇-深入了解关于栈的经典解法(栈实现:中缀表达式转后缀)

    🔥博客主页: 【 小扳_-CSDN博客】 ❤感谢大家点赞👍收藏⭐评论✍     文章目录         1.0 中缀表达式转后缀说明         1.1 实现中缀表达式转后缀思路         2.0 逆波兰表达式求值         2.1 实现逆波兰表达式求值思路         3.0 有效的括号         3.1 实现有

    2024年02月04日
    浏览(60)
  • 数据结构 实验2——表达式求值

    一、实验名称:表达式求值 二、实验学时: 6 学时 三、实验目的 1.理解栈的结构特点和基本操作特性; 2.掌握利用栈实现表达式求值算法。 四、实验内容 ( 步骤 ) 输入一个算术表达式(以“=”结束),求其值。要求表达式以“=”结束,操作数为多位实数,对错误表达式要进行

    2023年04月08日
    浏览(39)
  • 数据结构 | 栈的中缀表达式求值

    目录 什么是栈? 栈的基本操作 入栈操作 出栈操作 取栈顶元素 中缀表达式求值 实现思路 具体代码 栈是一种线性数据结构,具有“先进后出”(Last In First Out, LIFO)的特点。它可以看作是一种受限的线性表,只能在表的一端进行插入和删除操作,这一端被称为栈顶,另一端

    2024年02月02日
    浏览(57)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包