【数据结构】c++栈的应用：波兰式、逆波兰式和中缀表达式计算器
*********************************************************************************************************
本文作者科大MF22某班Noah懒羊羊同学，为大家提供一个作业思路，请勿直接copy！！！一起进步学习~
**********************************************************************************************************
目录
1.问题的描述
1.1基本功能
1.2健壮性
1.3 规范性
2.算法的描述
2.1数据结构的描述
2.2程序结构的描述
3.调试分析
4.算法的时空分析
5.测试结果及分析
代码附录
Noah_stack.h
Noah_Cal_Expression_With_Stack.h
Noah_expression_noemaltoRPN.h
Main.cpp
1.问题的描述
1.1基本功能
1. 波兰式计算
+ 2 * 3 - 5 1= 2 + 3 * (5 - 1)=14(11分)
+ + 2 * 3 - 7 4 / 8 4=2+3*(7-4)+8/4=13(12分)
2. 逆波兰式计算
2 3 5 1 - * += 2 + 3 * (5 - 1)=14(11分)
9 3 1 – 3* + 10 2 / +=9+(3-1)*3+10/2=20(12分)
3. 中缀式计算
(1)4 + 2 * 3 – 10 / 5 计算结果，应输出8(12分)；
(2)(4+2)*3 – 10 / 5 计算结果，应输出16(12分)；
1.2健壮性
- 程序对异常有一定的处理，如非法输入等
例如：
输入表达式有非法字符，(2分)
如：+ 2 A 、 2 3 A - 、 4 + a
- 输入表达式操作数和运算符数目不匹配(操作数多或运算符多)(4分)
如：+ 2 2 2 、 2 2 2 + 、 2 + 2 2 、+ + 2 2 、2 2 + +、 2 + + 2
- 输入表达式括号无法完成配对等非法输入。(4分)
如( 4 + 2 * 3、4 + 2)* 3。
1.3 规范性
- 代码注释
- 程序模块化
- 人机交互友好
2.算法的描述
2.1数据结构的描述
程序中应用到的主要数据结构是顺序栈。
主要变量说明：
| 变量 |
类型 |
说明 |
| sq_stack |
结构体 |
栈的结构体 |
| *base |
栈的底部元素指针 |
用于访问栈的底部元素，控制栈的存储，计算站的元素个数等 |
| *top |
栈的顶部元素指针 |
用于访问栈的顶部元素，控制栈的存储，计算站的元素个数等 |
| stack_size |
int |
顺序栈的内存空间大小(可存储的元素个数) |
| expression |
string |
需要计算表达式 |
| STACK_INIT_SIZE |
宏定义 |
初始化存储空间大小 |
| STACK_INCREMENT_SIZE |
宏定义 |
存储空间分配增量大小 |
| STK_Elemtype |
宏定义 |
栈中元素的数据类型 |
2.2程序结构的描述
程序主要包含Noah_stack.h、Noah_expression_normaltoRPN.h、Noah_Cal_Expression_With_Stack.h头文件和main.cpp主文件，其中Noah_stack.h是栈数据结构的实现代码头文件，Noah_expression_normaltoRPN.h是将中缀表达式转为后缀表达式(逆波兰式)的代码集合头文件、Noah_Cal_Expression_With_Stack.h是调用栈数据结构和表达式转换代码实现的计算不同表达式的功能的代码集合头文件，main.cpp中主要实现菜单和功能界面的交互以及头文件中函数的调用。其具体结构如下图所示。
3.调试分析
调试功能一：Polish expression calculator
计算波兰式表达式
测试数据选择:
- + 2 * 3 - 5 1= 2 + 3 * (5 - 1)=14(11分)
- + + 2 * 3 - 7 4 / 8 4=2+3*(7-4)+8/4=13(12分)
问题及解决方法：
- 由于io输入获得的是字符串数据类型，因此需要进行符号和数字的识别，但在识别十位数或者位数更高的数字时一开始没有识别成一个数字，而是识别成了多个数字，解决方法是添加了相应的判断控制代码，解决这一问题。
调试功能二：Inverse Polish expression calculator
计算逆波兰式表达式
测试数据选择:
- 2 3 5 1 - * += 2 + 3 * (5 - 1)=14(11分)
- 9 3 1 – 3 * + 10 2 / +=9+(3-1)*3+10/2=20(12分)
问题及解决方法：
- 一开始的代码中没有区分“10”是数字1和数字0还是一个数字10，为解决这一问题，限制输入时每一个数字和运算符之间需要加一个空格。
调试功能三：Infix expression calculator
计算中缀表达式
测试数据选择:
- 4 + 2 * 3 – 10 / 5 计算结果，应输出8(12分)；
- (4+2)*3 – 10 / 5 计算结果，应输出16(12分)；
问题及解决方法：
无
调试功能四：稳健性测试
测试数据选择:
- 1 + ( 5 * 6 – 10
- a , a + 5
- 2 3 A –
- + + 2 2
- 4 + 2)* 3
问题及解决方法：
无
4.算法的时空分析
(1)STK_Elemtype Polish_type_calculate(string expression)
时间复杂度：O(n)
空间复杂度：O(n)
(2)STK_Elemtype Inverse_Polish_type_calculate(string expression)
时间复杂度：O(n)
空间复杂度：O(n)
(3)STK_Elemtype Normal_type_calculate(string expression)
时间复杂度：O(n)
空间复杂度：O(n)
5.测试结果及分析
测试功能一：Polish expression calculator
| 测试用例 |
结果 |
分析 |
| + 2 * 3 - 5 1 |
|
√，波兰式计算正确 |
| + + 2 * 3 - 7 4 / 8 4 |
|
√ |
调试功能二：Inverse Polish expression calculator
| 测试用例 |
结果 |
分析 |
| 2 3 5 1 - * + |
|
√，逆波兰式计算正确 |
| 9 3 1 – 3 * + 10 2 / + |
|
√ |
测试功能三：Infix expression calculator
| 测试用例 |
结果 |
分析 |
| 4 + 2 * 3 – 10 / 5 |
|
√，中缀表达式计算正确 |
| ( 4 + 2) * 3 – 10 / 5 |
|
√ |
调试功能四：健壮性测试
| 测试用例 |
结果 |
分析 |
| 1 + ( 5 * 6 – 10 |
|
√ |
| a , a + 5 |
|
√ |
| 2 3 A – |
|
√ |
| 4 + 2) * 3 |
|
√ |
| + + 2 2 |
|
√ |
代码附录
Noah_stack.h
#ifndef NOAH_STACK_H_INCLUDED
#define NOAH_STACK_H_INCLUDED
#include
#define STACK_INIT_SIZE 100//初始化存储空间大小
#define STACK_INCREMENT_SIZE 10//存储空间分配增量大小
#define STK_Elemtype float
typedef struct{
STK_Elemtype *base;
STK_Elemtype *top;
int stack_size;
}sq_stack;
//初始化栈（顺序栈）
void initStack(sq_stack &s){
s.base = (STK_Elemtype *)malloc(STACK_INIT_SIZE * sizeof(STK_Elemtype));
/*
if(!s.base)
exit(overflow_error);//内存空间不足初始化失败，程序退出
*/
s.top = s.base;
s.stack_size = STACK_INIT_SIZE;
}
//为顺序栈重新分配空间并将空间扩大incrementsize*sizeof(element)
void incrementStack(sq_stack &s,int incrementsize){
s.base =(STK_Elemtype *)realloc(s.base,(s.stack_size + incrementsize)*sizeof(STK_Elemtype));
/*
if(!s.base)
exit(overflow_error);//内存空间不足，增加size失败，程序退出
*/
s.top = s.base + s.stack_size;
s.stack_size += incrementsize;
}
//判断链表是否为空
int isStackempty(sq_stack s){
if(s.base==s.top)
return 1;//空
else
return 0;//非空
}
//判断链表是否存满
int isStackfull(sq_stack s){
if(s.top - s.base >=s.stack_size)
return 1;//存满
else
return 0;//没有存满
}
//取栈顶元素
STK_Elemtype GetTop(sq_stack s){
//首先判断元素是否为空
if(isStackempty(s)){
cout << "The stack is Empty, return -1." << endl;
return STK_Elemtype(-1);
}
else
return *(s.top - 1);
}
//入栈
void push(sq_stack &s,STK_Elemtype e){
if(isStackfull(s))
incrementStack(s,STACK_INCREMENT_SIZE);
*s.top++ = e;
}
//出栈
STK_Elemtype pop(sq_stack &s){
if(isStackempty(s)){
cout << "The stack is Empty, return -1." << endl;
return STK_Elemtype(-1);
}
else
//cout<<"pop:"<<*(s.top-1);
return *--s.top;
}
//返回链表中的元素个数
int len_Stack(sq_stack s){
return s.top-s.base;
}
//打印链表中所有元素
void Display_Stack(sq_stack s){
if(isStackempty(s)){
printf("The stack is Empty.");
return ;
}
for(int i = 0 ; i Noah_Cal_Expression_With_Stack.h
#ifndef NOAH_CAL_EXPRESSION_WITH_STACK_H_INCLUDED
#define NOAH_CAL_EXPRESSION_WITH_STACK_H_INCLUDED
#include "Noah_stack.h"
#include "Noah_expression_normaltoRPN.h"
#include
#include
#include
#include
using namespace std;
string input_expression();
int check_expression(string expression);
STK_Elemtype Polish_type_calculate(string expression);
STK_Elemtype Inverse_Polish_type_calculate(string expression);
STK_Elemtype Normal_type_calculate(string expression);
//输入一个表达式
string input_expression(){
int legal = 0;
char expression_chars[256];
string expression;
while(!legal){
cout <<"Please input the expression:"<0 && x==' '){
temp = "";
operands_num++;
}
if(x=='('||x==')'||x==' '){
if(x=='(')
bracket_left++;
else if(x == ')')
bracket_right++;
continue;
}
if(x=='+'||x=='-'||x=='*'||x=='/'||x=='%'||x=='^')
operation_num++;
else if(x>='0'&&x<='9'){
temp +=x;
if(index == expression.size()-1)
operands_num++;
}
else
expression_error_illegal_char = 1;//有非法字符
//cout<0 && x==' '){
push(s,stof(temp));
temp = "";
}
/*
cout<='0'&&x<='9'){
temp = x + temp;
if(index==0)
push(s,stof(temp));
}
}
return pop(s);
}
//计算逆波兰式
STK_Elemtype Inverse_Polish_type_calculate(string expression){
sq_stack s;
initStack(s);
//正序遍历表达式字符串
string temp = "";
for (decltype(expression.size()) index = 0; index != expression.size(); index++){
char x = expression[index];
if(temp.size()>0 && x==' '){
push(s,stof(temp));
temp = "";
}
/*
cout<='0'&&x<='9'){
temp = temp + x;
if(index==expression.size()-1)
push(s,stof(temp));
}
}
return pop(s);
}
//计算中缀表达式,先转为逆波兰式再计算逆波兰式
STK_Elemtype Normal_type_calculate(string expression){
return Inverse_Polish_type_calculate(RPN(expression));
}
#endif // NOAH_CAL_EXPRESSION_WITH_STACK_H_INCLUDED
Noah_expression_noemaltoRPN.h
#ifndef NOAH_EXPRESSION_NORMALTORPN_H_INCLUDED
#define NOAH_EXPRESSION_NORMALTORPN_H_INCLUDED
#include
#include
#include
#include "Noah_stack.h"
using namespace std;
int priority_func(char op);
//判断运算符的优先级
int priority_func(char op)
{
int priority;
if(op == '*' || op == '/') priority = 2;
if(op == '+' || op == '-') priority = 1;
if(op == '(') priority = 0;
return priority;
}
//将中缀表达式转为逆波兰式
string RPN(string str)
{
string str1="";
stack s;
int i;
string temp = "";
for(i = 0; i < str.size(); i ++ )
{
//cout<0){
str1 = str1+ " " + temp;
temp = "";
}
continue;
}
//是数字的情况下直接输出
if(str[i] >= '0' && str[i] <= '9' )
{
temp = temp+string(1,str[i]);
if(i==str.size()-1)
str1 = str1+ " " + temp;
}
else //不是数字的情况分类讨论进行判断
{
//栈为空时直接入栈
if(s.empty()) s.push(str[i]);
//左括号入栈
else if(str[i] == '(') s.push(str[i]);
//如果是右括号，只要栈顶不是左括号，就弹出并输出
else if(str[i] == ')')
{
while(s.top() != '(')
{
str1 = str1+ " " + s.top();
s.pop();
}
//弹出左括号，但不输出
s.pop();
}
else
{
//栈顶元素的优先级大于等于当前的运算符，就将其输出
while(priority_func(str[i]) <= priority_func(s.top()))
{
str1 = str1+ " " + s.top();
s.pop();
//栈为空，停止
if(s.empty()) break;
}
s.push(str[i]);
}
}
}
//最后，如果不为空，就把所以的元素全部弹出
while(!s.empty())
{
str1 = str1+ " " + s.top();
s.pop();
}
string str2 = str1.substr(1,str1.size());
str1 = str2;
return str1;
}
#endif // NOAH_EXPRESSION_NORMALTORPN_H_INCLUDED
Main.cpp
#include
using namespace std;
#include
#include
#include
#include "Noah_Cal_Expression_With_Stack.h"
void Menue_gui();
void func1();
void func2();
void func3();
int main()
{
while(1){
Menue_gui();
int func;
scanf("%d",&func);
switch(func){
case 0:
exit(0);
case 1:
func1();break;
case 2:
func2();break;
case 3:
func3();break;
default:
printf("Input error! Please try again!");
}
printf("\n");
system("pause");
}
return 0;
}
//菜单界面
void Menue_gui(){
system("cls");//清屏
printf("****************Polish, inverse Polish, and infix expression calculators*********************\n");
printf("*********************************************************************************************\n");
printf("Menue:\n");
printf("\nExit this program------------------------------------------------------0.\n");
printf("\nPolish expression calculator-------------------------------------------1.\n");
printf("\nReverse Polish expression calculator-----------------------------------2.\n");
printf("\nInfix expression calculator--------------------------------------------3.\n");
printf("\n**********************************************************************************************\n");
printf("Choose the function you want to use(input number):\n");
}
//功能1界面
void func1(){
system("cls");//清屏
printf("-----ENTER FUNCTION : Polish expression calculator--1.-----\n");
printf("Input Polish expression(example:+ 2 * 3 - 5 1)\n");
string polish_expression;
polish_expression = input_expression();
float reslut = float(Polish_type_calculate(polish_expression));
printf("Result:%.2f",reslut);
}
//功能2界面
void func2(){
system("cls");//清屏
printf("-----ENTER FUNCTION : Inverse Polish expression calculator--2-----.\n");
printf("Input Inverse Polish expression(example:2 3 5 1 - * +)\n");
string Inverse_polish_expression;
Inverse_polish_expression = input_expression();
float reslut = float(Inverse_Polish_type_calculate(Inverse_polish_expression));
printf("Result:%.2f",reslut);
}
//功能3界面
void func3(){
system("cls");//清屏
printf("-----ENTER FUNCTION : Infix expression calculator--3.-----\n");
printf("Input Infix expression(example:4 + 2 * 3 – 10 / 5)\n");
string Infix_expression;
Infix_expression = input_expression();
float reslut = float(Normal_type_calculate(Infix_expression));
printf("Result:%.2f",reslut);
}