第1关:基于栈的中缀算术表达式求值
任务描述
本关任务:输入一个中缀算术表达式,求解表达式的值。运算符包括+、-、*、/、(、)、=,参加运算的数为double类型且为正数。(要求:直接针对中缀算术表达式进行计算,不能转换为后缀或前缀表达式再进行计算,只考虑二元运算即可。)
编程要求
输入
多组数据,每组数据一行,对应一个算术表达式,每个表达式均以“=”结尾。当表达式只有一个“=”时,输入结束。参加运算的数为double类型。
输出
对于每组数据输出一行,为表达式的运算结果。输出保留两位小数。
测试说明
平台会对你编写的代码进行测试:
测试输入: 2+2=
20*(4.5-3)=
=
预期输出: 4.00
30.00
开始你的任务吧,祝你成功!
#include <iostream>
#include<iomanip>
#define MAXSIZE 100
#define OK 1
#define ERROR 0
#define OVERFLOW -2
using namespace std;
typedef struct
{//运算符栈
char *base;
char *top;
int stacksize;
}SqStack1;
int InitStack1(SqStack1 &S)
{//运算符栈初始化
S.base=new char[MAXSIZE];
if(!S.base) return OVERFLOW;
S.top=S.base;
S.stacksize=MAXSIZE;
return OK;
}
int Push1(SqStack1 &S, char e)
{//运算符栈入栈
if(S.top-S.base==S.stacksize) //栈满
return ERROR;
*S.top=e;
S.top++;
return OK;
}
int Pop1(SqStack1 &S)
{//运算符栈出栈
if(S.top==S.base) //栈空
return ERROR;
S.top--;
return OK;
}
char GetTop1(SqStack1 S)
{//运算符栈取栈顶元素
if(S.top!=S.base)
return *(S.top-1);
return ERROR;
}
typedef struct
{//操作数栈
double *base;
double *top;
int stacksize;
}SqStack2;
int InitStack2(SqStack2 &S)
{//操作数栈初始化
S.base=new double[MAXSIZE];
if(!S.base) return OVERFLOW;
S.top=S.base;
S.stacksize=MAXSIZE;
return OK;
}
int Push2(SqStack2 &S,double e)
{//操作数栈入栈
if(S.top-S.base==S.stacksize) //栈满
return ERROR;
*S.top=e;
S.top++;
return OK;
}
int Pop2(SqStack2 &S)
{//操作数栈出栈
if(S.top==S.base) //栈空
return ERROR;
S.top--;
return OK;
}
double GetTop2(SqStack2 S)
{//操作数栈取栈顶元素
if(S.top!=S.base)
return *(S.top-1);
return ERROR;
}
double Calculate(double a,char op,double b)
{//计算表达式“a op b”的值
switch(op)
{
case '+':return a+b;
case '-':return a-b;
case '*':return a*b;
case '/':return a/b;
}
}
char Precede(char a,char b)
{//比较运算符a和b的优先级
if((a=='('&&b==')')||(a=='='&&b=='='))
return '=';
else if(a=='('||a=='='||b=='('||(a=='+'||a=='-')&&(b=='*'||b=='/'))
return '<';
else
return '>';
}
double EvaluateExpression(SqStack1 OPTR,SqStack2 OPND,char s[])
{//算术表达式求值的算符优先算法
/**************begin************/
int i,x=0,e=0,flag=0;
for(i=0;s[i]!='\0';i++){
if('0'<=s[i]&&s[i]<='9'){
flag = 1;
x=x*10+(s[i]-'0');
if(e!=0) e=e*10;
}else if(s[i]=='.'){
e = 1;
}else{
if(flag!=0){
double number = x;
if(e!=0) number = number/e;
Push2(OPND,number);
x=e=flag=0;
}
while(1){
if(Precede(GetTop1(OPTR),s[i])=='<'){
Push1(OPTR,s[i]);
break;
}else if(Precede(GetTop1(OPTR),s[i])=='>'){
double b = GetTop2(OPND);
Pop2(OPND);
double a = GetTop2(OPND);
Pop2(OPND);
char oper = GetTop1(OPTR);
Pop1(OPTR);
Push2(OPND,Calculate(a,oper,b));
}else{
Pop1(OPTR);
break;
}
}
}
}
return GetTop2(OPND);
/**************end************/
}
int main()
{//设OPTR和OPND分别为运算符栈和操作数栈
SqStack1 OPTR;
InitStack1(OPTR); //初始化OPND栈
SqStack2 OPND;
InitStack2(OPND); //初始化OPTR栈
Push1(OPTR,'='); //将表达式起始符“=”压入OPTR栈
char s[100];
while(cin>>s)
{//循环读入多组数据
if(s[0]=='=')
break; //当表达式只有一个“=”时,输入结束
//输出中缀算术表达式的值
cout<<fixed<<setprecision(2)<<EvaluateExpression(OPTR,OPND,s)<<fixed<<setprecision(2)<<endl;
}
return 0;
}
第2关:双栈的基本操作
任务描述
本关任务:将编号为0和1的两个栈存放于一个数组空间V[m]中,栈底分别处于数组的两端。当第0号栈的栈顶指针top[0]等于-1时该栈为空;当第1号栈的栈顶指针top[1]等于m时,该栈为空。两个栈均从两端向中间增长(见下图)。试编写双栈初始化,判断栈空、栈满、进栈和出栈算法的函数。函数调用次序依次为:进栈、栈满的判断、出栈、栈空的判断。
双栈数据结构的定义如下:
typedef struct
{
int top[2], bot[2]; //栈顶和栈底指针
SElemType *V; //栈数组
int m; //栈最大可容纳元素个数
}DblStack;
编程要求
输入
多组数据,每组数据有四行,每行的数据之间均用空格分隔。第一行为一个整数m,表示数组V的大小,第二行为四个整数e0、e1、d0、d1,e0和e1分别代表压入0号栈和1号栈的整数序列E0和E1的长度(依次连续入栈,中间没有出栈的情况),d0和d1分别代表从0号栈和1号栈弹出的序列的长度(依次连续出栈,中间没有入栈的情况)。第三行和第四行分别表示序列E0和E1。当m=0时,输入结束。
输出
对于每组数据输出三行。第一行代表进栈操作完成时栈是否为满(出栈操作尚未执行),栈满输出1,栈不满输出0。第二行和第三行的数据分别对应0号栈和1号栈。第二行包括d0+1个整数,其中前d0个整数代表出栈序列D0,最后一个整数代表出栈操作完成时0号栈是否为空,栈空输出0,不空输出1。第三行包括d1+1个整数,其中前d1个整数代表出栈序列D1,最后一个整数代表出栈操作完成时1号栈是否为空,栈空输出0,不空输出1。整数之间用空格分隔。
测试说明
平台会对你编写的代码进行测试:
测试输入: 7
3 4 2 2
1 2 3
2 3 4 5
12
4 6 4 3
1 3 4 5
1 3 5 6 8 1
0
预期输出: 1
3 2 1
5 4 1
0
5 4 3 1 0
1 8 6 1
#include<iostream>
using namespace std;
typedef struct
{
int top[2],bot[2];//栈顶和栈底指针
int *V;//栈数组
int m;//栈最大可容纳元素个数
}DblStack;
void InitDblStack(DblStack &S,int m)
{//初始化一个大小为m的双向栈
S.V=new int[m]; //动态分配一个最大容量为m的数组空间
S.bot[0]=-1; //左栈栈底指针
S.bot[1]=m; //右栈栈底指针
S.top[0]=-1; //左栈栈顶指针
S.top[1]=m; //右栈栈顶指针
}
int IsEmpty(DblStack S,int i)
{//判断指定的i号栈是否为空,空返回1,否则返回0
return S.top[i]==S.bot[i];
}
int IsFull(DblStack S)
{//判断栈是否满,满则返回1,否则返回0
if(S.top[0]+1==S.top[1]) return 1;
else return 0;
}
void Push(DblStack &S,int i)
{//向指定的i号栈中插入元素x,先移动指针再入栈
/**************begin************/
//插入元素,得考虑是否栈满
if(S.top[0]+1 == S.top[1]) return;
int x;
cin>>x;
if(i==0) S.top[i]++;
else S.top[i]--;
S.V[S.top[i]] = x;
/**************end************/
}
void Pop(DblStack &S,int i)
{//删除指定的i号栈的栈顶元素,先出栈再移动指针
/**************begin************/
if(S.top[i] == S.bot[i]) return; //栈空
cout<<S.V[S.top[i]]<<" ";
if(i==0) S.top[i]--;
else S.top[i]++;
/**************end************/
}
int main()
{
DblStack S;
int m,e0,e1,d0,d1;
while(cin>>m)
{
if(m==0) break;
InitDblStack(S,m);
cin>>e0>>e1>>d0>>d1;
while(e0--)
Push(S,0);
while(e1--)
Push(S,1);
cout<<IsFull(S)<<endl;
while(d0--)
Pop(S,0);
cout<<!IsEmpty(S,0)<<endl;
while(d1--)
Pop(S,1);
cout<<!IsEmpty(S,1)<<endl;
}
return 0;
}
第3关:基于栈的回文字符序列判断
任务描述
本关任务:回文序列是正反读均相同的字符序列,如“abba”和“abdba”均是回文,但是“good”不是回文。请设计一个算法判定给定的字符序列是否为回文。
编程要求
输入
多组数据,每组数据有一行。每一行为一个长度不定的字符序列A。当A为“0”时,输入结束。
输出
对于每组数据输出一行。若字符序列A是回文序列,则输出“YES”,否则输出“NO”。
测试说明
平台会对你编写的代码进行测试:
测试输入: abba
abdba
good
0
预期输出: YES
YES
NO
#include <iostream>
#define MAXSIZE 100
#define OK 1
#define ERROR 0
#define OVERFLOW -2
using namespace std;
typedef struct
{
char *base;
char *top;
int stacksize;
}SqStack;
int InitStack(SqStack &S)
{//栈初始化
S.base=new char[MAXSIZE];
if(!S.base) return OVERFLOW;
S.top=S.base;
S.stacksize=MAXSIZE;
return OK;
}
int Push(SqStack &S, char e)
{//入栈
if(S.top-S.base==S.stacksize) //栈满
return ERROR;
*S.top=e;
S.top++;
return OK;
}
int Pop(SqStack &S)
{//出栈返回栈顶元素
if(S.top==S.base) //栈空
return ERROR;
S.top--;
return *S.top;
}
int IsPalindrome(SqStack &S,char *t)
{//判断栈的回文字符序列
/**************begin************/
//1.入栈 2.按正常判断回文的思路走
//出栈入栈的代码要烂熟于心
int len = 0;
for (int i = 0; t[i] != '\0'; i++) { // 先将输入字符串的所有字符压入栈中
Push(S, t[i]);
len++;
}
for(int i = 0;i < len/2;i++){
if(t[i] != Pop(S)) return 0;
}
return 1;
/**************end************/
}
int main()
{
char t[100];
while(cin>>t&&t[0]!='0')
{
SqStack S;
InitStack(S);
if(IsPalindrome(S,t)==1) cout<<"YES"<<endl;
else cout<<"NO"<<endl;
}
return 0;
}
第4关:入栈和出栈的基本操作
任务描述
本关任务:输入一个整数序列a1,a2,a3...,an。当ai不等于-1时将ai进栈;当ai=-1时,输出栈顶元素并将其出栈。
编程要求
输入
多组数据,每组数据有两行,第一行为序列的长度n,第二行为n个整数,整数之间用空格分隔。当n=0时输入结束。
输出
对于每一组数据输出若干行。每行为相应的出栈元素。当出栈异常时,输出“POP ERROR”并结束本组数据的输出。
测试说明
平台会对你编写的代码进行测试:
测试输入: 5
1 2 -1 -1 1
5
1 -1 -1 2 2
0
预期输出: 2
1
1
POP ERROR
#include<iostream>
using namespace std;
#define MAXSIZE 100
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef struct
{
int *base;
int *top;
int stacksize;
}SqStack;
int InitSqStack(SqStack &S)
{//栈的初始化
S.base=new int[MAXSIZE];
if(!S.base) return OVERFLOW;
S.top=S.base;
S.stacksize=MAXSIZE;
return OK;
}
int Push(SqStack &S,int e)
{//入栈
if(S.top-S.base==S.stacksize) //栈满
return ERROR;
*S.top=e;
S.top++;
return OK;
}
int Pop(SqStack &S)
{//出栈
if(S.top==S.base) //栈空
return ERROR;
S.top--;
return OK;
}
int GetTop(SqStack S)
{//取栈顶元素
if(S.top==S.base) //栈空
return ERROR;
return *(S.top-1);
}
void InOutS(SqStack &S,int a[],int n)
{//入栈和出栈的基本操作
/**************begin************/
for(int i = 0;i < n;i++){
if(a[i]!=-1) Push(S,a[i]);
else{
if(S.top!=S.base){
cout<<GetTop(S)<<endl;
Pop(S);
}else{
cout<<"POP ERROR"<<endl;
return;
}
}
}
/**************end************/
}
int main()
{
int n;
while(cin>>n)
{
if(n==0) break;
SqStack S;
InitSqStack(S);
int a[n];
for(int i=0;i<n;i++) cin>>a[i]; //整数序列
InOutS(S,a,n);
}
return 0;
}
第5关:基于栈的后缀算术表达式求值
任务描述
本关任务:从键盘上输入一个后缀表达式,试编写算法计算表达式的值。规定:后缀表达式的长度不超过一行,以“=”作为输入结束,操作数之间用空格分隔,操作符只可能有+、?、*、/四种运算。
编程要求
输入
多组数据,每组数据一行,对应一个后缀算术表达式,每个表达式均以“=”结尾。当表达式只有一个“=”时,输入结束。
输出
对于每组数据输出一行,为表达式的运算结果。
测试说明
平台会对你编写的代码进行测试:
测试输入: 1 2+8 2-7 4-/*=
1 2+=
1 2/=
=
预期输出: 6.00
3.00
0.50
#include <iostream>
#include<iomanip>
#include <string>
#define MAXSIZE 100
#define OK 1
#define ERROR 0
#define OVERFLOW -2
using namespace std;
typedef struct
{//数字栈
double *base;
double *top;
int stacksize;
}SqStack;
int InitStack(SqStack &S)
{//数字栈初始化
S.base=new double[MAXSIZE];
if(!S.base) return OVERFLOW;
S.top=S.base;
S.stacksize=MAXSIZE;
return OK;
}
int Push(SqStack &S,double e)
{//数字栈入栈
if(S.top-S.base==S.stacksize) //栈满
return ERROR;
*S.top=e;
S.top++;
return OK;
}
int Pop(SqStack &S)
{//数字栈出栈
if(S.top==S.base) //栈空
return ERROR;
S.top--;
return OK;
}
double GetTop(SqStack S)
{//数字栈取栈顶元素
if(S.top!=S.base)
return *(S.top-1);
return ERROR;
}
double Calculate(double a,char op,double b)
{//算术表达式的求值
switch(op)
{
case '+':return a+b;
case '-':return a-b;
case '*':return a*b;
case '/':return a/b;
}
}
double EvaluateExpression(SqStack OPND,char s[])
{//后缀算术表达式求值
/**************begin************/
//后缀算术表达式求值
int i,x=0,e=0,flag=0;
//x和e辅助存储double型数
//flag用于判断某个double类型数据是否读入完全
for(i=0;s[i]!='=';i++)
{
if('0'<=s[i]&&s[i]<='9')
{
flag=1;
x=x*10+(s[i]-'0');//x存储去掉小数点后的数据,如原数据1.23,最终得到的x为123
if(e!=0) e=e*10;//小数点后有几位,e扩大为10的几倍
}
else if(s[i]=='.')
e=1;
else
{
if(flag!=0)
{
double number=x;
if(e!=0) number=number/e;//如果其间有小数点出现,number缩小对应的倍数
Push(OPND,number);//将double类型数据入栈
x=e=flag=0;//复原x、e、flag
}
if(s[i]==' ') continue;
double b=GetTop(OPND);
Pop(OPND);
double a=GetTop(OPND);
Pop(OPND);
char oper=s[i];
Push(OPND,Calculate(a,oper,b));//将运算结果压入数字栈
}
}
return GetTop(OPND);
/**************end************/
}
int main()
{
char s[100];
//用字符数组存储表达式,每个数组元素仅存一个字符
while(1)
{
cin.getline(s,100); //输入一行含空格的后缀表达式
if(s[0]=='=')
break; //当表达式只有一个"="时,输入结束
SqStack OPND;
InitStack(OPND); //初始化数字栈
cout<<fixed<<setprecision(2)<<EvaluateExpression(OPND,s)<<fixed<<setprecision(2)<<endl;
}
return 0;
}
第6关:基于栈的可操作判断
任务描述
本关任务:假设I和O分别代表入栈和出栈操作。栈的始态和终态均为空。入栈和出栈的操作序列可以表示为仅由I和O组成的序列,称可操作的序列为合法序列,否则称为非法序列。请设计一个算法,判断所给的操作序列是否合法。若合法输出“true”,反之输出“false”。
编程要求
输入
多组数据,每组数据一行,对应一个后缀算术表达式,每个表达式均以“=”结尾。当表达式只有一个“=”时,输入结束。
输出
多组数据,每组数据为一行长度不定的操作序列A。当A为“0”时,输入结束。
测试说明
平台会对你编写的代码进行测试:
测试输入: IOIOIO
IIOOOO
0
预期输出: TRUE
FALSE
#include <iostream>
#define MAXSIZE 100
#define OK 1
#define ERROR 0
#define OVERFLOW -2
using namespace std;
typedef struct
{
char *base;
char *top;
int stacksize;
}SqStack;
int InitStack(SqStack &S)
{//初始化栈
S.base=new char[MAXSIZE];
if(!S.base) return OVERFLOW;
S.top=S.base;
S.stacksize=MAXSIZE;
return OK;
}
int Push(SqStack &S)
{//入栈
S.top++;
return OK;
}
int Pop(SqStack &S)
{//出栈
S.top--;
return OK;
}
int IsEmpty(SqStack S)
{//判断栈是否为空,空返回1,否则返回0
return S.top==S.base;
}
bool Judge(char a[],SqStack &S)
{//栈的可操作判断
/**************begin************/
int i = 0;
//写循环前先思考是否知道运行次数
while(a[i] != '\0'){ //'\0' 表示空字符(null字符)
if(a[i] == 'I'){
if(S.top - S.base == S.stacksize) return false;
Push(S);
}else if(a[i] == 'O'){
if(S.top == S.base) return false;
Pop(S);
}
i++;
}
return IsEmpty(S);
/**************end************/
}
int main()
{
char a[100];
while(cin>>a)
{
if(a[0]=='0') break;
SqStack op;
InitStack(op);
if(Judge(a,op)) cout<<"TRUE"<<endl;
else cout<<"FALSE"<<endl;
}
return 0;
}