用栈数据结构对算数表达式求值的思想

• 问题描述

        表达式求值是程序设计语言编译中的一个基本问题，是栈应用的一个典型例子。对于一个简单的算数表达式，假如它的操作数是整型常数，运算符有加减乘除四种运算符，界限符有左右括号、表达式起始符和表达式结束符（#）。那么，它应遵循算数四则运算的规则是：从左到右，先括号内，后括号外，先乘除后加减。

• 算法分析

        要对一个算数表达式求值，首先要了解算符（运算符和界限符）间的优先关系，即算数表达式的计算顺序，从而决定如何对表达式进行操作。对算数表达式进行扫描，任意两个相继出现的算符θ₁和θ₂之间的优先关系比较如表所示。

---

算符间的优先关系比较

	+	-	*	/	（	）	#
+	>	>	<	<	<	>	>
-	>	>	<	<	<	>	>
*	>	>	>	>	<	>	>
/	>	>	>	>	<	>	>
(	<	<	<	<	<	=	-
)	>	>	>	>	-	>	>
#	<	<	<	<	<	-	=

第一行表示θ₂，第一列表示θ₁，“-”表示此情况不存在

        由表可知，θ₁和θ₂之间存在以下三种关系：

1.        θ₁ > θ₂ ：θ₁ 的优先级高于 θ₂ ，应执行θ₁ 对应的运算；
2.        θ₁ < θ₂ :  θ₁ 的优先级低于 θ₂ ，不执行任何运算，继续扫描下一运算符；
3.        θ₁ = θ₂ :  θ₁ 的优先级等于 θ₂ ，两者为左右括号或同为#。

        要实现以上算符优先算法需使用两个栈，一个称作运算符栈（OPTR），用于存放运算符；另一个称作操作数栈（OPND），用于存放操作数或运算结果。算法的基本思想是：

1. 初始化OPTR和OPND两个栈，并将表达式起始符“#”作为OPTR栈的栈底元素。
2. 依次读入表达式中的每个字符，若是操作数则进OPND栈，若是运算符，则与OPTR栈的栈顶元素进行优先级比较，并执行相应的操作：

• 若栈顶运算符的优先级低于刚读入的运算符（θ₁<θ₂），则刚读入的运算符进OPTR栈；
• 若栈顶运算符的优先级与刚读入的运算符优先级相同（θ₁=θ₂），说明左右括号相遇，即将栈顶运算符（左括号）出栈；
• 若栈顶运算符的优先级高于刚读入的运算符（θ₁>θ₂），则将栈顶运算符出栈送入θ，同时OPND栈弹出两个操作数a和b，对a和b执行θ运算并使运算结果进OPND栈。

   3. 当OPND栈的栈顶元素和当前读入字符均为“#”，整个表达式求值完毕，OPND栈的栈顶元素即为表达结果。

        利用栈实现算数表达式 2*(35-10)+5 的过程如下表所示。

步骤	1	2	3	4	5	6	7	8	9	10	11	12	13
OPTR栈	#	#	#    *	#    * （	#   *（	#   *（   -	#   *（  -	#   *（	#    *	#	#   +	#   +	#
OPND栈		2	2	2	2 35	2 35	2 35 10	2 25	2 25	50	50	50   5	55
当前读入字符	2	*	（	35	-	10	）	）	+	+	5	#	#

C语言的实现：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#define MAXSIZE 100

char op[7] = { '+', '-', '*', '/', '(', ')', '#' };
char cmp[7][7] = {
	{ '>', '>', '<', '<', '<', '>', '>' },
	{ '>', '>', '<', '<', '<', '>', '>' },
	{ '>', '>', '>', '>', '<', '>', '>' },
	{ '>', '>', '>', '>', '<', '>', '>' },
	{ '<', '<', '<', '<', '<', '=', ' ' },
	{ '>', '>', '>', '>', ' ', '>', '>' },
	{ '<', '<', '<', '<', '<', ' ', '=' }
};

//定义运算符栈
typedef struct
{
	char elem[MAXSIZE];
	int top;
}SeqStackR;

//定义操作数栈
typedef struct
{
	int elem[MAXSIZE];
	int top;
}SeqStackD;

//初始化运算符栈
void InitStackR(SeqStackR* S)
{
	S->top = 0;
}

//初始化操作数栈
void InitStackD(SeqStackD* S)
{
	S->top = 0;
}

//运算符进栈
void PushR(SeqStackR* S, char e)
{
	if (S->top == MAXSIZE)
		printf("The operator stack is full!\n");
	else
	{
		S->elem[S->top] = e;
		S->top++;
	}
}

//操作数进栈
void PushD(SeqStackD* S, int e)
{
	if (S->top == MAXSIZE)
		printf("The operand stack is full!\n");
	else
	{
		S->elem[S->top] = e;
		S->top++;
	}
}

//运算符出栈
void PopR(SeqStackR* S, char* e)
{
	if (S->top == 0)
		printf("The operator stack is null!\n");
	else
	{
		S->top--;
		*e = S->elem[S->top];
	}
}

//操作数出栈
void PopD(SeqStackD* S, int* e)
{
	if (S->top == 0)
		printf("The operand stack is null!\n");
	else
	{
		S->top--;
		*e = S->elem[S->top];
	}
}

//运算符栈取栈顶元素
char GetTopR(SeqStackR* S)
{
	if (S->top == 0)
		printf("The operator stack is null!\n");
	else
		return (S->elem[S->top - 1]);
}

//操作数取栈顶元素
int GetTopD(SeqStackD* S)
{
	if (S->top == 0)
		printf("The operand stack is null!\n");
	else
		return (S->elem[S->top - 1]);
}

//输入字符是否属于运算符集合，如果是，返回它在数组中的位置；否则返回-1
int Isoperator(char ch)
{
	int i;
	for (i = 0; i < 7; i++)
	{
		if (ch == op[i])
			return i;
	}
	return -1;
}

//比较两个运算符的优先级
char Compare(char ch1, char ch2)
{
	int m, n;
	m = Isoperator(ch1);
	n = Isoperator(ch2);
	return cmp[m][n];
}

//返回两个操作数运算的结果
int Execute(int a, char theta, int b)
{
	int result = 0;
	switch (theta)
	{
	case '+':
		result = a + b;
		break;
	case '-':
		result = a - b;
		break;
	case '*':
		result = a * b;
		break;
	case '/':
		result = a / b;
		break;
	default:
		break;
	}
	return result;
}

//输入算数表达式并求值
int EvaluateExp()
{
	char ch, theta;
	int a = 0, b = 0, k = 0, x = 0;
	char str[50] = { 0 };
	SeqStackR OPTR;
	SeqStackD OPND;
	InitStackR(&OPTR);
	InitStackD(&OPND);

	printf("Please input expreeion:\n");
	PushR(&OPTR, '#');
	gets(str);
	ch = str[k];
	k++;

	while (ch != '#' || GetTopR(&OPTR) != '#')
	{
		if (Isoperator(ch) == -1)
		{
			x = ch - '0';
			ch = str[k];
			k++;
			while (Isoperator(ch) == -1)
			{
				x = x * 10 + ch - '0';
				ch = str[k];
				k++;
			}
			PushD(&OPND, x);
		}
		else
		{
			switch (Compare(GetTopR(&OPTR), ch))
			{
			case '<':
				PushR(&OPTR, ch);
				ch = str[k];
				k++;
				break;
			case '=':
				PopR(&OPTR, &ch);
				ch = str[k];
				k++;
				break;
			case '>':
				PopR(&OPTR, &theta);
				PopD(&OPND, &b);
				PopD(&OPND, &a);
				PushD(&OPND, Execute(a, theta, b));
				break;
			}
		}
	}
	return GetTopD(&OPND);
}

int main()
{
	printf("The value of expression is:%d\n", EvaluateExp());

	return 0;
}