栈的应用：四则运算表达式求值

最新推荐文章于 2022-10-24 08:00:00 发布
最新推荐文章于 2022-10-24 08:00:00 发布
阅读量5.4k 收藏 23
点赞数 10
分类专栏： C 数据结构 文章标签： c 数据结构 栈 四则运算
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lub0807/article/details/37884417
版权

栈的一个应用是求四则运算表达式的值，这里的表达式包含数字、加减乘除4种运算符，以及小括号。

由于输入是一个字符串，因此解决这个问题需要以下3个步骤：

1、输入字符串转化为中缀表达式；

2、中缀表达式转化为后缀表达式；

3、后缀表达式求值。

现在表达式为：9 + （ 3 - 1 ）* 3 + 10 / 2 ，先看一下运行结果：


首先解释一下中缀表达式和后缀表达式的概念。所谓中缀表达式，就是我们平常书写的表达式，因为运算符是写在两个参与运算的数字中间，所以叫中缀表达式，例如1 + 2 。与此对应，后缀表达式就是运算符写在数字后面，比如刚才的算式就要写成1 2 + ，我们看起来的确有点奇怪，不过计算机却很喜欢这种表达式。下面分析解决问题的3个步骤。

1、输入字符串转化为中缀表达式

运算符号和括号好办，本身就是字符，只需要把字符串形式的数字转成相应的整数。我采用的方法是，用一个数组num[]存储整数的各位数字，用一个整型变量count记录位数。当下一个字符是运算符或者括号时，表示整数已经读取完毕。这时候，把num数组的各位数字乘以10的某次方就可还原出该整数。该部分代码如下：

//字符串转换成中缀表达式
void StringToMidExp(const char exp[], Stack *ps)
{
	int num[MAX_INT];
	int k, n, count, temp;
	Stack m_stack;
	Stack *pm;
	Node *q;

	k = 0;
	count = 0;
	pm = &m_stack;
	InitStack(pm);

	while (exp[k] != '\0')
	{
		if (exp[k] >= '0' && exp[k] <= '9') //数字0到9
		{
			count++;					//count记录整数的位数
			num[count-1] = exp[k] - 48;	//num数组记录整数的每一位
		}
		else if ((exp[k] >= 40 && exp[k] <= 43) || exp[k] == 45 || exp[k] == 47) //运算符
		{
			if (count > 0) //转换该运算符之前的数字
			{
				n = 0;
				temp = 0;
				while (n < count)
				{
					temp += num[n] * TenPow(count - n -1); //每一位乘以10的某次方
					n++;
				}				
				q = (Node *)malloc(sizeof(Node));
				q->type = NUM;
				q->number = temp;
				Push(pm, q);
			}
			count = 0; //位数清零
			q = (Node *)malloc(sizeof(Node));
			q->type = OP;
			q->operation = exp[k];
			Push(pm, q);
		}
		k++;
	}
	if (count > 0) //把最后一个数字转换出来
	{
		n = 0;
		temp = 0;
		while (n < count)
		{
			temp += num[n] * TenPow(count - n -1);
			n++;
		}
		q = (Node *)malloc(sizeof(Node));
		q->type = NUM;
		q->number = temp;
		Push(pm, q);
	}
	Reverse(pm, ps); //颠倒一下次序
}

//计算10的n次方
int TenPow(int n)
{
	if (n == 0)
	{
		return 1;
	} 
	else
	{
		int i, k;
		i = 0;
		k = 1;
		while (i < n)
		{
			k *= 10;
			i++;
		}
		return k;
	}
}
2、中缀表达式转后缀表达式

这里需要一个栈用来暂时存储运算符和括号，具体地，对中缀表达式从左到右按以下规则操作：

（1）遇到数字，则直接输出；

（2）遇到左括号，则左括号进栈；

（3）遇到右括号，从栈顶开始依次输出所有运算符，直到遇到左括号，这个左括号也出栈；

（4）遇到加号或减号，从栈顶开始依次输出所有运算符，直到遇到左括号，但此时这个左括号不出栈，并且当前运算符进栈；

（5）遇到乘号或除号，如果栈顶是乘号或除号，则输出，否则不输出，并且当前运算符进栈。

这部分代码如下：

//中缀表达式转换成后缀表达式
void MidExpToBackExp(Stack *pm, Stack *pb)
{
	Stack tempStack, oprStack;
	Stack *pt, *pr;
	Node *q, *r;

	pt = &tempStack;	//临时存储后缀表达式
	pr = &oprStack;		//用来决定运算符的顺序
	InitStack(pt);
	InitStack(pr);

	while (pm->top)
	{
		q = (Node *)malloc(sizeof(Node));
		Pop(pm, q);
		if (q->type == NUM)
		{
			Push(pt, q);
		} 
		else
		{
			if (q->operation == '+' || q->operation == '-')
			{
				while (pr->top && pr->top->operation != '(')
				{
					r = (Node *)malloc(sizeof(Node));
					Pop(pr, r);
					Push(pt, r);
				}
				Push(pr, q);
			}
			else if (q->operation == '*' || q->operation == '/')
			{
				while (pr->top && pr->top->operation != '(' && pr->top->operation != '+' && pr->top->operation != '-')
				{
					r = (Node *)malloc(sizeof(Node));
					Pop(pr, r);
					Push(pt, r);
				}
				Push(pr, q);
			}
			else if (q->operation == '(')
			{
				Push(pr, q);
			} 
			else
			{
				while (pr->top)
				{
					if (pr->top->operation == '(')
					{
						r = (Node *)malloc(sizeof(Node));
						Pop(pr, r);
						free(r);
						break;
					}
					r = (Node *)malloc(sizeof(Node));
					Pop(pr, r);
					Push(pt, r);
				}
				free(q);
			}
		}
	}
	while (pr->top) //栈内剩余运算符全部出栈
	{
		r = (Node *)malloc(sizeof(Node));
		Pop(pr, r);
		Push(pt, r);
	}
	Reverse(pt, pb); //颠倒一下次序
}
3、后缀表达式求值

这里还需要一个栈，只不过这回是用来暂时存储数字，注意到后缀表达式中不含有括号了。具体地，对后缀表达式从左到右按以下规则操作：

（1）遇到数字，则数字进栈；

（2）遇到运算符，则栈顶数字出栈，记为num1，此时栈顶数字再出栈，记为num2，那么记num2 运算 num1 = num3，将num3进栈。还是举个例子好了，比如遇到运算符+，栈顶数字是1，好了，1出栈。现在栈顶数字变为2了，好，2也出栈。现在计算2+1=3，此时，3进栈。

这部分代码如下：

//根据后缀表达式计算结果
int BackExpToResult(Stack *ps)
{
	if (!ps->top) //空栈说明表达式有误
	{
		return NO_RESULT;
	}

	Stack tempStack;
	Stack *pt;
	Node *q;
	int num_left, num_right, result;

	pt = &tempStack;
	InitStack(pt);
	while (ps->top)
	{
		if (ps->top->type == NUM)
		{
			q = (Node *)malloc(sizeof(Node));
			Pop(ps, q);
			Push(pt, q);
		} 
		else
		{
			q = (Node *)malloc(sizeof(Node));
			Pop(pt, q);
			num_right = q->number;
			free(q);

			if (!pt->top) //pt栈内没有第2个数了，说明表达式有误
			{
				return NO_RESULT;
			}

			q = (Node *)malloc(sizeof(Node));
			Pop(pt, q);
			num_left = q->number;
			free(q);

			q = (Node *)malloc(sizeof(Node));
			Pop(ps, q);
			switch(q->operation)
			{
			case '+':
				result = num_left + num_right;
				break;
			case '-':
				result = num_left - num_right;
				break;
			case '*':
				result = num_left * num_right;
				break;
			case '/':
				result = num_left / num_right;
				break;				
			}
			free(q);

			q = (Node *)malloc(sizeof(Node));
			q->type = NUM;
			q->number = result;
			Push(pt, q);
		}
	}
	q = (Node *)malloc(sizeof(Node));
	Pop(pt, q);
	result = q->number;
	free(q);

	if (pt->top) //pt栈内还有数字，说明表达式有误
	{
		return NO_RESULT;
	} 
	else
	{
		return result;
	}
}
整个工作完成，不过，程序要想正确运行，对输入有一些要求，比如：

（1）输入不能有空字符；

（2）输入的数字只能是整数，而且除数不能是0；

（3）确保中间的运算结果也都是整数，否则会舍弃小数部分，从而影响精度。

全部代码如下：

#include <STDIO.H>
#include <STDLIB.H>

#define MAX_EXP 100			//表达式最大长度
#define MAX_INT 10			//整数最大位数
#define NO_RESULT -99999	//计算异常的返回值

enum node_type{ NUM, OP };

struct node{
	int number;
	char operation;
	enum node_type type;
	struct node *next;
};

struct stack{
	struct node *top;
	int length;
};

typedef struct node Node;
typedef struct stack Stack;

int GetResult(const char []);
void StringToMidExp(const char [], Stack *);
int TenPow(int);
void MidExpToBackExp(Stack *, Stack *);
int BackExpToResult(Stack *);
void ShowStack(const Stack *);
void ShowNode(const Node *);
void InitStack(Stack *);
void Push(Stack *, Node *);
void Pop(Stack *, Node *);
void ClearStack(Stack *);
void Reverse(Stack *, Stack *);

int main(void)
{
	char expression[MAX_EXP];
	int result;

	printf("输入四则运算表达式：\n");
	scanf("%s", expression);

	result = GetResult(expression);
	if (result == NO_RESULT)
	{
		printf("表达式有误，计算失败。\n");
	} 
	else
	{
		printf("计算结果是：%d\n", result);
	}

	return 0;
}

//根据表达式的字符串计算结果
int GetResult(const char exp[])
{
	Stack middleExp, backExp;
	Stack *pm, *pb;

	pm = &middleExp;
	pb = &backExp;
	InitStack(pm);
	InitStack(pb);
	StringToMidExp(exp, pm);
	printf("中缀表达式：");
	ShowStack(pm);
	MidExpToBackExp(pm, pb);
	printf("后缀表达式：");
	ShowStack(pb);

	return BackExpToResult(pb);
}

//字符串转换成中缀表达式
void StringToMidExp(const char exp[], Stack *ps)
{
	int num[MAX_INT];
	int k, n, count, temp;
	Stack m_stack;
	Stack *pm;
	Node *q;

	k = 0;
	count = 0;
	pm = &m_stack;
	InitStack(pm);

	while (exp[k] != '\0')
	{
		if (exp[k] >= '0' && exp[k] <= '9') //数字0到9
		{
			count++;					//count记录整数的位数
			num[count-1] = exp[k] - 48;	//num数组记录整数的每一位
		}
		else if ((exp[k] >= 40 && exp[k] <= 43) || exp[k] == 45 || exp[k] == 47) //运算符
		{
			if (count > 0) //转换该运算符之前的数字
			{
				n = 0;
				temp = 0;
				while (n < count)
				{
					temp += num[n] * TenPow(count - n -1); //每一位乘以10的某次方
					n++;
				}				
				q = (Node *)malloc(sizeof(Node));
				q->type = NUM;
				q->number = temp;
				Push(pm, q);
			}
			count = 0; //位数清零
			q = (Node *)malloc(sizeof(Node));
			q->type = OP;
			q->operation = exp[k];
			Push(pm, q);
		}
		k++;
	}
	if (count > 0) //把最后一个数字转换出来
	{
		n = 0;
		temp = 0;
		while (n < count)
		{
			temp += num[n] * TenPow(count - n -1);
			n++;
		}
		q = (Node *)malloc(sizeof(Node));
		q->type = NUM;
		q->number = temp;
		Push(pm, q);
	}
	Reverse(pm, ps); //颠倒一下次序
}

//计算10的n次方
int TenPow(int n)
{
	if (n == 0)
	{
		return 1;
	} 
	else
	{
		int i, k;
		i = 0;
		k = 1;
		while (i < n)
		{
			k *= 10;
			i++;
		}
		return k;
	}
}

//中缀表达式转换成后缀表达式
void MidExpToBackExp(Stack *pm, Stack *pb)
{
	Stack tempStack, oprStack;
	Stack *pt, *pr;
	Node *q, *r;

	pt = &tempStack;	//临时存储后缀表达式
	pr = &oprStack;		//用来决定运算符的顺序
	InitStack(pt);
	InitStack(pr);

	while (pm->top)
	{
		q = (Node *)malloc(sizeof(Node));
		Pop(pm, q);
		if (q->type == NUM)
		{
			Push(pt, q);
		} 
		else
		{
			if (q->operation == '+' || q->operation == '-')
			{
				while (pr->top && pr->top->operation != '(')
				{
					r = (Node *)malloc(sizeof(Node));
					Pop(pr, r);
					Push(pt, r);
				}
				Push(pr, q);
			}
			else if (q->operation == '*' || q->operation == '/')
			{
				while (pr->top && pr->top->operation != '(' && pr->top->operation != '+' && pr->top->operation != '-')
				{
					r = (Node *)malloc(sizeof(Node));
					Pop(pr, r);
					Push(pt, r);
				}
				Push(pr, q);
			}
			else if (q->operation == '(')
			{
				Push(pr, q);
			} 
			else
			{
				while (pr->top)
				{
					if (pr->top->operation == '(')
					{
						r = (Node *)malloc(sizeof(Node));
						Pop(pr, r);
						free(r);
						break;
					}
					r = (Node *)malloc(sizeof(Node));
					Pop(pr, r);
					Push(pt, r);
				}
				free(q);
			}
		}
	}
	while (pr->top) //栈内剩余运算符全部出栈
	{
		r = (Node *)malloc(sizeof(Node));
		Pop(pr, r);
		Push(pt, r);
	}
	Reverse(pt, pb); //颠倒一下次序
}

//根据后缀表达式计算结果
int BackExpToResult(Stack *ps)
{
	if (!ps->top) //空栈说明表达式有误
	{
		return NO_RESULT;
	}

	Stack tempStack;
	Stack *pt;
	Node *q;
	int num_left, num_right, result;

	pt = &tempStack;
	InitStack(pt);
	while (ps->top)
	{
		if (ps->top->type == NUM)
		{
			q = (Node *)malloc(sizeof(Node));
			Pop(ps, q);
			Push(pt, q);
		} 
		else
		{
			q = (Node *)malloc(sizeof(Node));
			Pop(pt, q);
			num_right = q->number;
			free(q);

			if (!pt->top) //pt栈内没有第2个数了，说明表达式有误
			{
				return NO_RESULT;
			}

			q = (Node *)malloc(sizeof(Node));
			Pop(pt, q);
			num_left = q->number;
			free(q);

			q = (Node *)malloc(sizeof(Node));
			Pop(ps, q);
			switch(q->operation)
			{
			case '+':
				result = num_left + num_right;
				break;
			case '-':
				result = num_left - num_right;
				break;
			case '*':
				result = num_left * num_right;
				break;
			case '/':
				result = num_left / num_right;
				break;				
			}
			free(q);

			q = (Node *)malloc(sizeof(Node));
			q->type = NUM;
			q->number = result;
			Push(pt, q);
		}
	}
	q = (Node *)malloc(sizeof(Node));
	Pop(pt, q);
	result = q->number;
	free(q);

	if (pt->top) //pt栈内还有数字，说明表达式有误
	{
		return NO_RESULT;
	} 
	else
	{
		return result;
	}
}

//显示栈中元素
void ShowStack(const Stack *ps)
{
	if (ps->top)
	{
		Node *p = ps->top;
		while (p->next)
		{
			ShowNode(p);
			printf(" ");
			p = p->next;
		}
		ShowNode(p);
		printf("\n");
	} 
	else
	{
		printf("无\n");
	}
}

//显示一个节点元素
void ShowNode(const Node *p)
{
	if (p->type == NUM)
	{
		printf("%d", p->number);
	} 
	else
	{
		printf("%c", p->operation);
	}
}

//初始化栈
void InitStack(Stack *ps)
{
	ps->length = 0;
	ps->top = NULL;
}

//节点入栈
void Push(Stack *ps, Node *pn)
{
	pn->next = ps->top;
	ps->top = pn;
	ps->length++;
}

//节点出栈
void Pop(Stack *ps, Node *pn)
{
	if (ps->top)
	{
		Node *q = ps->top;
		pn->next = NULL;
		pn->number = q->number;
		pn->operation = q->operation;
		pn->type = q->type;
		ps->top = q->next;
		free(q);
		ps->length--;
	} 
	else
	{
		pn = NULL;
	}
}

//清空栈
void ClearStack(Stack *ps)
{
	Node *q;

	while (ps->top)
	{
		q = ps->top;
		ps->top = q->next;
		free(q);
		ps->length--;
	}
}

//反转栈中元素的次序
void Reverse(Stack *ps1, Stack *ps2)
{
	if (ps1->top)
	{
		Node *q;

		ClearStack(ps2);
		while (ps1->top)
		{
			q = (Node *)malloc(sizeof(Node));
			Pop(ps1, q);
			Push(ps2, q);
		}
	} 
	else
	{
		ps2->top = NULL;
		ps2->length = 0;
	}
}

宝宝丶0807
关注
  • 10
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C语言-用栈实现表达式求值
m0_63223213的博客
07-02 1万+
为实现算符优先算法，可以使用两个工作栈。一个称做 OPTR，用以寄存运算符；另一个称做 OPND，用以寄存操作数或运
栈-表达式求值
辣条不爱辣的博客
10-04 1078
表达式求值是程序设计语言编译中的一个最基本问题。它的实现是栈应用的有一个典型例子。 这里使用算符优先法。 输入:一个表达式. 输出：输出其后缀表达式并且进行表达式的求值。 运行结果： 算法思想： 拿当前扫描的运算符号与上一个比较优先级，当前扫描符号低或相等则进行上一个运算，需取最近的两个数。否则扫下个。 设操作符栈与操作数栈，运算符栈最初压如‘#’，逐个扫描符号。遇操作数则直接入...
使用栈实现计算四则运算
qq_29414875的博客
11-30 1338
问题： 刚开始学JAVA时候写一个简易计算器是很容易的，比如说让用户输入一个表达式1+2=？，我们只需要判断给定两个int，一个String,变量就可以直接运算出来。 然而用户输入的是一个四则运算表达式呢？ 比如： 2+3*2=？ 3+2-1=? 2*(1+3)-6-(2/1)=? 3+(2*(1+2))=？ 我们可以发现在这些算式中有两个问题： 1.算式长度不定 2.需要考虑优
数据结构2.2栈的应用--表达式求值
m0_63944721的博客
05-10 455
表达式求值算法说明代码实现运行结果 算法说明 在课上听了上一级学长的代码，觉得受益匪浅。奈何学艺不精，只能在理解代码之后用自己会的c语言来尝试实现。 在上课听的时候，我就在想表达式求值的逻辑究竟是怎样的。首先，我们需要两个栈，一个用于存放数字，一个用于存放运算符。有一个难点是运算符是有优先级顺序的，究竟应该怎么去实现这个优先级，这里借鉴了别人的算法：二维数组。并且（）’优先级最高，‘（’和‘）’优先级相同，故若优先级相同，则说明是括号。如果栈顶运算符和扫描到的运算符相同，则栈顶运算符优先级高。例如：栈顶运算
算术表达式求值(栈结构及其应用) - C语言
最新发布
友人帐_的博客
10-24 1万+
表达式求值是实现程序设计语言的基本问题之一，也是栈的应用的一个典型例子。一个算术表达式是由操作数（operand）、运算符（operator）和界限符（delimiter）组成的。假设操作数是正整数，运算符只含加减乘除等四种二元运算符，界限符有左右括号和表达式起始、如：（7+15）*（23-28/4）。引入表达式起始、结束符是为了方便。设计一个程序，演示算术表达式求值的过程。
栈表达式求值（c语言数据结构）
awm123453的博客
05-10 3819
1、头文件 #include <iostream> #include <stdio.h> 2、定义常量 #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define MAXSIZE 100 #define OVERFLOW -2 3、个性化设置 using namespace std; typedef char SElemType; typedef int NElemType; typedef int St
四则运算表达式求值
11-12
总的来说，解决四则运算表达式求值的问题需要深入理解数据结构（如栈）、运算符优先级规则以及基本的编程技巧。通过这个课程设计，不仅可以巩固C++的基础知识，还能提升对数据结构和算法的理解与应用能力。
C++四则运算表达式求值算法
08-29
C++中实现四则运算表达式求值的一个常见方法是使用栈数据结构。栈是一种后进先出（LIFO）的数据结构，非常适合处理具有优先级的运算符。我们可以遍历表达式，遇到数字时压入栈，遇到运算符时检查栈顶元素，如果当前...
数据结构:栈的应用-四则算术表达式求解
04-17
在这个主题中，我们将深入探讨栈如何应用于四则算术表达式的求解以及如何通过它来判断表达式的合法性。 栈是一种具有后进先出（Last In First Out，简称LIFO）特性的数据结构，类似于我们日常生活中使用的叠放物品...
C语言中栈和队列实现表达式求值的实例
08-29
例如，我们可以使用栈来实现一个简单的四则运算表达式的求值： ```c void EvaluateExpression(){ Stack s; StackInit(&s); // 将操作数和操作符压入栈中 Push(&s, 1); Push(&s, 2); Push(&s, '+'); // 从栈...
C和Python实现运算表达式的求值
07-12
总结来说，本项目通过C语言和Python展示了如何利用栈数据结构实现四则运算表达式的求值。C语言实现更注重底层细节和效率，而Python实现则更加简洁和灵活。这两种方法都可以帮助我们理解表达式求值的基本逻辑，同时也...
四则运算表达式求值（栈的应用）
fangleijiang的专栏
04-08 1042
1.前/中/后缀表达式的转换（首先需要明白三者之间的转换）      自然表达式转换为前/中/后缀表达式，其实是很简单的。首先将自然表达式按照优先级顺序，构造出与表达式相对应的二叉树，然后对二叉树进行前/中/后缀遍历，即得到前/中/后缀表达式。     举例说明将自然表达式转换成二叉树：     a×(b+c)-d     ① 根据表达式的优先级顺序，首先计算(b+c)，形成二
[AcWing] 3302. 表达式求值 （C++实现）---栈例题
cloud的博客
12-27 716
[AcWing] 3302. 表达式求值 （C++实现）---栈例题1. 题目2. 读题（需要重点注意的东西）3. 解法4. 可能有帮助的前置习题5. 所用到的数据结构与算法思想6. 总结 1. 题目 2. 读题（需要重点注意的东西） 思路： 解题思路： 定义运算符优先级 代码实现思路： 3. 解法 ---------------------------------------------------解法-------------------------------------------------
用栈实现算数表达式求值（C语言（基础版））
liuchiang03的博客
04-01 1万+
用栈结构来计算简单的算术表达式
栈的应用 后缀表达式求值 后缀表达式与中缀表达式的转换
刘耀的博客
07-02 1032
栈的应用在计算机里面进行算数表达式的计算是通过栈来实现的。接下来给出算数表达式的两种表示方法，然后给出后缀表达式的求值算法，最后给出中缀表达式转换为后缀表达式的算法。一、中缀表达式与后缀表达式算数表达式：算数表达式一般由三部分组成，1操作数、2运算符、3改变运算次序的圆括号。 中缀表达式：是将运算符放在两个操作数之间的表达式，也是我们生活、学习过程中常用的算数表达式。 后缀表达式：是将运算符放在
使用栈进行表达式求值的过程分析
前端之路
12-09 5956
栈的应用十分广泛，只要满足先进后出的特性就可以使用栈结构，表达式求值就是其中一个简单应用，下面以四则运算来举例说明： 1、中缀表达式 转换为 后缀表达式 中缀表达式 指运算符在两个运算对象之间，比如 23+（34*45）/（5+6+7） 后缀表达式 指不含括号，运算符在两个参与运算的语法成分后面，按照后缀表达式求值时，所有的求值计算皆按运算符出现的顺序，严格从左至右执行，比如 23 34 ...
栈的应用之表达式求值（后缀式运算）
学到的就要教人 赚到的就要给人
06-12 9786
1、逆波兰表达式简介  假定给定一个只 包含 加、减、乘、除，和括号的算术表达式，你怎么编写程序计算出其结果。问题是：在表达式中，括号，以及括号的多层嵌套 的使用，运算符的优先级不同等因素，使得一个算术表达式在计算时，运算顺序往往因表达式的内容而定，不具规律性。 这样很难编写出统一的计算指令。   使用逆波兰算法可以轻松解决。他的核心思想是将普通的中缀表达式转换为后缀表达式。  转换为后缀表达式的...
栈的应用：表达式求值问题
weixin_51235620的博客
04-03 1342
1基本思路 任何一个表达式都是由操作数(operand)、运算符(operator)和界限符(delimiter)组成，其中，操作数可以是常数也可以是被说明为变量或常量的标识符；运算符可以分为算术运算符、关系运算符和逻辑运算符等三类；基本界限符有左右括弧和表达式结束符等 。为了叙述简洁，在此仅限于讨论只含二元运算符的算术表达式。 由于算术运算的规则是：先乘除后加减、先左后右和先括弧内后括弧外，则对表达式进行运算不能按其中运算符出现的先后次序进行。 由于算术运算的规则是：先乘除后加减、先左后右和先括弧内后括弧
栈的应用——求解表达式
fawks96的专栏
02-10 1538
栈有很多经典的应用，求解表达式便是重要的一个。首先要认识栈的基本特征，那就是FILO（first-in-last-out)，先进后出。基本上符合先进后出这样一种模式的思想都能用栈来进行实现。那么现在回到我们这次的主题，求解表达式，为什么这会用到栈呢？换句话说，求解表达式哪里体现了先进后出的思想？我们来具体分析。       我们如果要计算这样一个式子：2*3，你会脱口而出是6，计算机也知道是6。
算术表达式求值：栈的应用与程序设计
在这个设计中，我们假设输入的表达式是不含变量的整数表达式，因此所有操作都是基于固定数值的四则运算。用户通过终端以字符序列的形式输入表达式，例如“3*（7-2）”。 为了实现求值过程，我们将遵循以下步骤： 1...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值