重庆邮电大学数据结构实验二

一、实验目的

1. 掌握栈的基本操作算法的实现，包括栈初始化、进栈、出栈、取栈顶元素

等。

2. 掌握利用栈实现中缀表达式求值的算法。

二、实验内容

问题描述

输入一个中缀算术表达式，求解表达式的值。运算符包括 “+” 、 “-” 、 “*” 、 “/” 、

“(” 、 “)” 、 “=” ，参加运算的数为整数。

要求 : 直接使用中缀算术表达式进行计算，不能转换为后缀或前缀表达式再进

行计算，只考虑二元运算即可。

输入要求

多组数据，每组数据一行，对应一个算术表达式，每个表达式均以 “=” 结尾。

当表达式只有一个 “= ” 时，输入结束。参加运算的数为 int 类型。

输出要求

对于每组数据输出 1 行，为表达式的运算结果。

输入样例

2+2=

20*(4-2)=

=

输出样例

4

40

#include<iostream>
#include<iomanip>
using namespace std;
#define MAXSIZE 50 //最大的算术表达式长度
#define OK 1
#define ERROR -1
/*
由于栈的主要操作是在栈顶插入和删除，显然以链表的头部作为栈顶是最方便的，
而且没必要像单链表那样为了操作方便，附加一个头结点
*/

//链栈的存储结构
typedef struct StackNode
{
	char data;
	struct StackNode* next;
}StackNode, * LinkStack;

//链栈的初始化
int InitStack(LinkStack& S)
{//构造一个空栈，栈顶指针置空
	S = NULL;
	return OK;
}

//链栈的入栈
/*
算法步骤：
1.未入栈元素e分配空间，用指针p指向
2.将新结点数据域置为e
3.将新结点插入栈顶
4.修改栈顶指针为p
*/
int Push(LinkStack& S, char e)
{//在栈顶插入元素
	LinkStack p = new StackNode;//生成新结点
	p->data = e;//将新节点的 数据域置为e
	p->next = S;//将新结点插入栈顶
	S = p;//修改栈顶指针为p
	return OK;
}

//链栈的出栈
/*
算法步骤：
1.判断栈是否为空，若空则返回ERROR
2.将栈顶元素赋给e
3.临时保存栈顶元素的空间，以备释放
4.修改栈顶指针，指向新的栈顶元素
5.释放原栈顶元素的空间
*/
char Pop(LinkStack& S, char& e)
{
	if (S == NULL)
		return ERROR;//栈空
	e = S->data;//将栈顶元素赋给e
	LinkStack p = S;//用p临时保存栈顶元素空间，以备释放
	S = S->next;//修改栈顶指针
	delete p;//释放原栈顶元素的空间
	return e;
}

//取栈顶元素
char GetTop(LinkStack S)
{//当栈顶非空时，此操作返回当前栈顶元素的值，栈顶指针S保持不变
	if (S != NULL)
	{
		return S->data;
	}
	else
	{
		return '?';
	}
}


//__________________________________________________________________________
//链栈的存储结构
typedef struct StackNoded
{
	int data;
	struct StackNoded* next;
}StackNoded, * LinkStackd;

//链栈的初始化
int InitStackd(LinkStackd& S)
{//构造一个空栈，栈顶指针置空
	S = NULL;
	return OK;
}

//链栈的入栈
int Pushd(LinkStackd& S, int e)
{//在栈顶插入元素
	LinkStackd p = new StackNoded;//生成新结点
	p->data = e;//将新节点的 数据域置为e
	p->next = S;//将新结点插入栈顶
	S = p;//修改栈顶指针为p
	return OK;
}

//链栈的出栈
int Popd(LinkStackd& S, int& e)
{
	if (S == NULL)
		return -1;//栈空
	e = S->data;//将栈顶元素赋给e
	LinkStackd p = S;//用p临时保存栈顶元素空间，以备释放
	S = S->next;//修改栈顶指针
	delete p;//释放原栈顶元素的空间
	return e;
}

//取栈顶元素
int GetTopd(LinkStackd S)
{//当栈顶非空时，此操作返回当前栈顶元素的值，栈顶指针S保持不变
	if (S != NULL)
	{
		return S->data;
	}
	else
	{
		return ERROR;
	}
}
//__________________________________________________________________________

//判断读入的字符ch是否为运算符
int In(char ch)
{
	if (ch == '+' || ch == '-' || ch == '*'
		|| ch == '/' || ch == '(' || ch == ')' || ch == '=')
		return true;
	else
		return false;
}

//theta1,theta2 比较它们的优先级
char Precede(char ch1, char ch2)
{
	char cmpResult = NULL;//返回的比较结果> < =
	switch (ch1)
	{
	case '?':
		cmpResult = '<';
		break;
	case '+':
		switch (ch2)
		{
		case '+':
			cmpResult = '>';
			break;
		case '-':
			cmpResult = '>';
			break;
		case '*':
			cmpResult = '<';
			break;
		case '/':
			cmpResult = '<';
			break;
		case '(':
			cmpResult = '<';
			break;
		case ')':
			cmpResult = '>';
			break;
		case '=':
			cmpResult = '>';
			break;
		default:
			break;
		}
		break;
	case '-':
		switch (ch2)
		{
		case '+':
			cmpResult = '>';
			break;
		case '-':
			cmpResult = '>';
			break;
		case '*':
			cmpResult = '<';
			break;
		case '/':
			cmpResult = '<';
			break;
		case '(':
			cmpResult = '<';
			break;
		case ')':
			cmpResult = '>';
			break;
		case '=':
			cmpResult = '>';
			break;
		default:
			break;
		}
		break;
	case '*':
		switch (ch2)
		{
		case '+':
			cmpResult = '>';
			break;
		case '-':
			cmpResult = '>';
			break;
		case '*':
			cmpResult = '>';
			break;
		case '/':
			cmpResult = '>';
			break;
		case '(':
			cmpResult = '<';
			break;
		case ')':
			cmpResult = '>';
			break;
		case '=':
			cmpResult = '>';
			break;
		default:
			break;
		}
		break;
	case '/':
		switch (ch2)
		{
		case '+':
			cmpResult = '>';
			break;
		case '-':
			cmpResult = '>';
			break;
		case '*':
			cmpResult = '>';
			break;
		case '/':
			cmpResult = '>';
			break;
		case '(':
			cmpResult = '<';
			break;
		case ')':
			cmpResult = '>';
			break;
		case '=':
			cmpResult = '>';
			break;
		default:
			break;
		}
		break;
	case '(':
		switch (ch2)
		{
		case '+':
			cmpResult = '<';
			break;
		case '-':
			cmpResult = '<';
			break;
		case '*':
			cmpResult = '<';
			break;
		case '/':
			cmpResult = '<';
			break;
		case '(':
			cmpResult = '<';
			break;
		case ')':
			cmpResult = '=';
			break;
		case '=':
			cmpResult = '>';
			break;
		default:
			break;
		}
		break;
	case ')':
		switch (ch2)
		{
		case '+':
			cmpResult = '>';
			break;
		case '-':
			cmpResult = '>';
			break;
		case '*':
			cmpResult = '>';
			break;
		case '/':
			cmpResult = '>';
			break;
		case '(':
			cmpResult = ' ';
			break;
		case ')':
			cmpResult = '>';
			break;
		case '=':
			cmpResult = '>';
			break;
		default:
			break;
		}
		break;
	case '=':
		break;
	default:
		break;
	}
	return cmpResult;
}

int Operate(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 EvaluateExpression(char* str)
{//算术表达式求值的算符优先法，设OPND和OPTR分别为操作数栈和运算符栈
	char ch;//当前字符
	LinkStack OPTR;
	LinkStackd OPND;
	InitStackd(OPND);//初始化OPND栈
	InitStack(OPTR);//初始化OPTR栈
	ch = str[0];
	int i = 0;//扫描字符串的下标
	//运算符 运算数a 运算数b
	char theta = NULL;
	int a = NULL;
	int b = NULL;
	char x = NULL;
	int i1 = 0;//数字和小数点构成的字符串下标
	char z[10] = {};//存放数字的字符串
	while (true)
	{
		//问题：这里用strcmp为什么出错？
		//int strcmp(const char* str1，const char* str2);
		//参数 str1 和 str2 是参与比较的两个字符串。而ch是char类型
		ch = str[i];//第i个字符
		if (ch == '\0')
			break;
		if (In(ch))//是运算符
		{
			ch = str[i];
			switch (Precede(GetTop(OPTR), ch))
			{//比较OPTR的栈顶元素和ch的优先级
			case '<':
				Push(OPTR, ch); i++; ch = str[i];
				break;
			case '>':
				Pop(OPTR, theta);//弹出栈顶的运算符
				Popd(OPND, b); Popd(OPND, a);//弹出栈顶的两个运算数
				Pushd(OPND, Operate(a, theta, b));//将运算结果压入OPND栈
				break;
			case '='://OPTR的栈顶元素是"("且ch")"
				Pop(OPTR, x); i++; ch = str[i];
				break;
			default:
				break;
			}
		}
		else if (ch >= '0' && ch <= '9')//数字
		{
			i1 = 0;
			do
			{
				z[i1] = ch;
				i1++;
				i++;
				ch = str[i];
			} while ((ch >= '0' && ch <= '9') || ch == '.');
			z[i1] = 0;
			int d = atof(z);
			Pushd(OPND, d);
		}
		else
		{
			cout << "输入错误" << endl;
			break;
		}
	}
	return GetTopd(OPND);
}

int main()
{
	char str[MAXSIZE] = {};//输入的字符串算术表达式
	char ch = NULL;
	int output = NULL;
	while (true)
	{
		cin >> str;//输入
		ch = str[0];
		if (ch == '=')
			break;
		else
		{
			cout << setiosflags(ios::fixed) << setprecision(2);
			output = EvaluateExpression(str);
			cout << output << endl;
		}
	}
}