BJFU 编程题实训-栈和队列

最新推荐文章于 2024-08-27 12:15:45 发布

不喜欢生葱的Ray

最新推荐文章于 2024-08-27 12:15:45 发布

阅读量1.4k

点赞数 7

文章标签： c++ 数据结构

本文链接：https://blog.csdn.net/weixin_73919230/article/details/133750960

版权

第一关：基于栈的中缀算术表达式求值

本关任务：输入一个中缀算术表达式，求解表达式的值。运算符包括+、-、*、/、(、)、=，参加运算的数为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************/
	//设OPTR和OPND分别为运算符栈和操作数栈
	//表达式求值算法调用Precede函数和Calculate函数
	Push1(OPTR, '=');		//把 = 作栈底
	char temp;
	double a = 0, b = 0;
	int i = 0;

	while (s[i] != '=' || GetTop1(OPTR) != '=' && i < MAXSIZE) {
		//操作数
		if (s[i] >= '0' && s[i] <= '9') {
			double result_int = 0;		//用于临时存储操作数
			// 整数部分
			while (s[i] != '.' && s[i] >= '0' && s[i] <= '9') {
				result_int = result_int * 10 + (s[i] - 48);
				i++;
			}

			// 小数部分
			double result_frac = 0;
			double Multiplier = 1.0 / 10;		//小数位的权数
			if (s[i] == '.') i++;
			while (s[i] >= '0' && s[i] <= '9') {
				result_frac += Multiplier * (s[i] - 48);
				Multiplier *= 1.0 / 10;
				i++;
			}

			double sum = 0;
			sum = result_int + result_frac;
			Push2(OPND, sum);
		}
		//运算符
		else
		{
			switch (Precede(GetTop1(OPTR), s[i])) {
				case '<':
					Push1(OPTR, s[i]);
					i++;
					break;
				case '>':
					//出栈
					temp = GetTop1(OPTR);
					Pop1(OPTR);

					a = GetTop2(OPND);
					Pop2(OPND);
					b = GetTop2(OPND);
					Pop2(OPND);

					//把运算结果入栈
					Push2(OPND, Calculate(b, temp, a));
					break;

				case '=':
					Pop1(OPTR);
					i++;
					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;
}

建议先完成第五关和第十二关，再来完成本关任务。

第二关：双栈的基本操作

本关任务：将编号为0和1的两个栈存放于一个数组空间V[m]中，栈底分别处于数组的两端。当第0号栈的栈顶指针top[0]等于-1时该栈为空；当第1号栈的栈顶指针top[1]等于m时，该栈为空。两个栈均从两端向中间增长（见下图）。试编写双栈初始化，判断栈空、栈满、进栈和出栈算法的函数。函数调用次序依次为：进栈、栈满的判断、出栈、栈空的判断。
输入：多组数据，每组数据有四行，每行的数据之间均用空格分隔。第一行为一个整数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 (IsFull(S))	return;		//栈满退出

	if (i == 0)		//左栈
	{
		S.top[0]++;
		cin >> S.V[S.top[0]];
	}
	else			//右栈
	{
		S.top[1]--;
		cin >> S.V[S.top[1]];
	}

	/**************end************/
}


void Pop(DblStack& S, int i)
{//删除指定的i号栈的栈顶元素，先出栈再移动指针
	/**************begin************/
	if (IsEmpty(S, i))	return;		//栈空退出

	if (i == 0)		// 左栈  
	{
		cout << S.V[S.top[0]] << " "; // 输出栈顶元素  
		S.top[0]--;
	}
	else			// 右栈  
	{
		cout << S.V[S.top[1]] << " "; // 输出栈顶元素  
		S.top[1]++;
	}

	/**************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;
}

第三关：基于栈的回文字符序列判断

本关任务：回文序列是正反读均相同的字符序列,如“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************/
	while (*t)		//入栈
	{
		Push(S, *t);
		t++;
	}

	S.top--;
	while (S.top - S.base > 1)
	{
		if (*S.base != *S.top)	return 0;
		else
		{
			S.base++;
			S.top--;
		}
	}
	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;
}

第四关：入栈和出栈的基本操作

本关任务：输入一个整数序列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 << "POP ERROR" << endl;
				break;
			}

			else					//非空则出栈
			{
				cout << GetTop(S) << endl;
				Pop(S);
			}
		}
	}
	/**************end************/
}


int main()
{
	int n;
	while (cin >> n)
	{
		if (n == 0) break;
		SqStack S;
		InitSqStack(S);
		int a[MAXSIZE];
		for (int i = 0; i < n; i++) cin >> a[i];  //整数序列
		InOutS(S, a, n);
	}
	return 0;
}

第五关：基于栈的后缀算术表达式求值

本关任务：从键盘上输入一个后缀表达式，试编写算法计算表达式的值。规定：后缀表达式的长度不超过一行，以“=”作为输入结束，操作数之间用空格分隔，操作符只可能有+、?、*、/四种运算。
输入：多组数据，每组数据一行，对应一个后缀算术表达式，每个表达式均以“=”结尾。当表达式只有一个“=”时，输入结束。
输出：对于每组数据输出一行，为表达式的运算结果。

测试输入：
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************/
	double a, b;
	int i = 0;

	while (s[i] != '=') {

		if (s[i] == ' ') {		//忽略空格
			i++;
		}
		else if (s[i] >= '0' && s[i] <= '9') {		//数字入栈
			double num = s[i] - 48;
			Push(OPND, num);
			i++;
		}
		else {			//运算符，数字出栈运算
			b = GetTop(OPND);
			Pop(OPND);
			a = GetTop(OPND);
			Pop(OPND);
			Push(OPND, Calculate(a, s[i], b));		// a + b ...
			i++;
		}
	}

	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;
}

第六关：基于栈的可操作判断

本关任务：假设I和O分别代表入栈和出栈操作。栈的始态和终态均为空。入栈和出栈的操作序列可以表示为仅由I和O组成的序列，称可操作的序列为合法序列，否则称为非法序列。请设计一个算法，判断所给的操作序列是否合法。若合法输出“TRUE”，反之输出“FALSE”。
输入：多组数据，每组数据为一行,长度不定的操作序列A。当A为“0”时，输入结束。
输出：每组数据输出一行，可操作为TRUE，不可操作为FALSE。

测试输入：
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])
	{
		if (a[i] == 'I')	Push(S);		//遇I入栈
		else			//出栈
		{
			if (IsEmpty(S))	return false;	//空栈报错并退出
			else	Pop(S);
		}
		i++;
	}

	//栈非空则有冗余项，返回false
	if (!IsEmpty(S))
		return false;
	return true;
	/**************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;
}

第七关：Ackermann函数的递归求值

本关任务：已知Ackermann函数定义如下：
在这里插入图片描述
写出计算Ack(m,n)的递归算法。
输入：多组数据，每组数据有一行，为两个整数m和n。当m和n都等于0时，输入结束。
输出：每组数据输出一行，为Ack(m,n)。

测试输入：
3 5
3 10
0 0

预期输出：
253
8189

#include<iostream>
using namespace std;


int Ack(int m,int n)
{//Ackermann函数的递归求值
    /**************begin************/
	if(m == 0)	return ++n;
	if(m > 0 && n == 0)		return Ack(m-1,1);
	return Ack(m-1,Ack(m,n-1));
	
    /**************end************/
}


int main()
{
	int m,n;
	while(cin>>m>>n)
    {
        if(m==0&&n==0) break;
        cout<<Ack(m,n)<<endl;
    }
	return 0;
}

第八关：Ackermann函数的非递归求值

本关任务：已知Ackermann函数定义如下：
在这里插入图片描述
写出计算Ack(m,n)的非递归算法。
输入：多组数据，每组数据有一行，为两个整数m和n。当m和n都等于0时，输入结束。
输出：每组数据输出一行，为Ack(m,n)。

测试输入：
2 1
0 0

预期输出：
5

#include<iostream>
using namespace std;
#define MAXSIZE 100


int Ack(int m, int n)
{//Ackermann函数的非递归求值
	/**************begin************/
	int akm[m + 1][100];
	for (int j = 0; j < 100; j++)
		akm[0][j] = j + 1;
	for (int i = 1; i <= m; i++)
	{
		akm[i][0] = akm[i - 1][1];
		for (int j = 1; j < 100; j++)
			akm[i][j] = akm[i - 1][akm[i][j - 1]];
	}
	return (akm[m][n]);


	/**************end************/
}


int main()
{
	int m, n;
	while (cin >> m >> n)
	{
		if (m == 0 && n == 0) break;
		cout << Ack(m, n) << endl;
	}
	return 0;
}

第九关：递归求解单链表中的最大值

本关任务：利用单链表表示一个整数序列，利用递归的方法求出单链表中整数的最大值。
输入：多组数据，每组数据有两行，第一行为链表的长度n，第二行为链表的n个元素（元素之间用空格分隔）。当n=0时输入结束。
输出：对于每组数据分别输出一行，输出每个链表的最大值。
测试说明：平台会对你编写的代码进行测试：

测试输入：
4
1 2 3 4
5
-1 2 39 2 3
0

预期输出：
4
39

#include <iostream>
using namespace std;

typedef struct LNode
{
    int data;
    struct LNode* next;
}LNode, * LinkList;

void CreateList_R(LinkList& L, int n)
{//后插法创建单链表
    L = new LNode;
    L->next = NULL;
    LinkList r = L;
    for (int i = 0; i < n; i++)
    {
        LinkList p = new LNode;
        cin >> p->data;
        p->next = NULL;
        r->next = p;
        r = p;
    }
}


int GetMax(LinkList L)
{//递归求解单链表中的最大值
    /**************begin************/
    int max;
    if (L->next == NULL)
        return L->data;
    else
    {
        max = GetMax(L->next);
        return L->data >= max ? L->data : max;
    }
    /**************end************/
}


int main()
{
    int n;
    while (cin >> n)
    {
        if (n == 0) break;
        LinkList L;
        CreateList_R(L, n);
        L = L->next;    //指向首元结点
        cout << GetMax(L) << endl;
    }
    return 0;
}

在GetMax函数中，首先递归让max等于列表中最后一项，然后返回上一层，运行 return L->data >= max ? L->data : max; 代码，将L目前所指的值与max（L的next的值）相比较，将最大的那一项赋给上一层的max，再次运行 return L->data >= max ? L->data : max; 代码，将L目前所指的值与max（上一次比较中最大的那一项）相比较，将最大的那一个赋给上一层的max，依此逻辑，递归找出列表中最大的那一项。

第十关：递归求解单链表中的结点个数

本关任务：利用单链表表示一个整数序列，利用递归的方法计算单链表中结点的个数。
输入：多组数据，每组数据有两行，第一行为链表的长度n，第二行为链表的n个元素（元素之间用空格分隔）。当n=0时输入结束。
输出：对于每组数据分别输出一行，对应链表中的各个结点个数。

测试输入：
4
1 2 3 4
6
1 2 43 5 7 2
0

预期输出：
4
6

#include <iostream>
using namespace std;

typedef struct LNode
{
    int data;
    struct LNode* next;
}LNode, * LinkList;

void CreateList_R(LinkList& L, int n)
{//后插法创建单链表
    L = new LNode;
    L->next = NULL;
    LinkList r = L;
    for (int i = 0; i < n; i++)
    {
        LinkList p = new LNode;
        cin >> p->data;
        p->next = NULL;
        r->next = p;
        r = p;
    }
}


int GetLength(LinkList L)
{//递归求解单链表中的结点个数
    /**************begin************/

    if (L->next == NULL)	return 1;
    return 1 + GetLength(L->next);

    /**************end************/
}


int main()
{
    int n;
    while (cin >> n)
    {
        if (n == 0) break;
        LinkList L;
        CreateList_R(L, n);
        L = L->next;    //L指向首元结点
        cout << GetLength(L) << endl;
    }
    return 0;
}

第十一关：递归求解单链表中的平均值**

本关任务：利用单链表表示一个整数序列，利用递归的方法计算单链表中各个结点的平均值。
输入：多组数据，每组数据有两行，第一行为链表的长度n，第二行为链表的n个元素（元素之间用空格分隔）。当n=0时输入结束。
输出：对于每组数据分别输出一行，对应链表中的各个结点的平均值，输出保留两位小数。

测试输入：
4
1 2 3 4
6
1 1 1 1 1 1
0

预期输出：
2.50
1.00

#include <iostream>
using namespace std;

typedef struct LNode
{
    int data;
    struct LNode* next;
}LNode, * LinkList;

void CreateList_R(LinkList& L, int n)
{//后插法创建单链表
    L = new LNode;
    L->next = NULL;
    LinkList r = L;
    for (int i = 0; i < n; i++)
    {
        LinkList p = new LNode;
        cin >> p->data;
        p->next = NULL;
        r->next = p;
        r = p;
    }
}


double GetAverage(LinkList L, int n)
{//递归求解单链表中的平均值
    /**************begin************/
    if (L->next == NULL)
        return L->data;
    else
    {
        double ave = GetAverage(L->next, n - 1);
        return (ave * (n - 1) + L->data) / n;
    }
    /**************end************/
}


int main()
{
    int n;
    while (cin >> n)
    {
        if (n == 0) break;
        LinkList L;
        CreateList_R(L, n);
        L = L->next;//L指向首元结点
        printf("%.2f\n", GetAverage(L, n));//输出保留两位小数
    }
    return 0;
}

递归思路同第九关
让 ave 最后一项、最后两项、最后三项 … 的平均值
代码 return (ave * (n - 1) + L->data) / n; 中 ave * (n - 1) 的含义为目前 L 所指后面所有项的和
代码 ave * (n - 1) + L->data 的含义为L 及其后所有项的和， / n用来计算其平均值，并返回
依次类推，最后返回的值为所有项的平均值

第十二关：中缀表达式转化为后缀表达式

本关任务：输入一个中缀算术表达式，将其转换为后缀表达式。运算符包括+、-、*、/、(、)、=，参加运算的为小于10的自然数。（只考虑二元运算即可）
输入：多组数据，每组数据一行，对应一个算术表达式，每个表达式均以“=”结尾。当表达式只有一个“=”时，输入结束。
输出：对于每组数据输出一行，为表达式的后缀式。

测试输入：
9+(3-1)*3+1/2=
1+2=
=

预期输出：
931-3*+12/+
12+

#include<iostream>
using namespace std;
#define  MAXSIZE  100
#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define Status int

typedef struct
{
	char* base;
	char* top;
	int stacksize;
}SqStack;

Status InitStack(SqStack& S)
{//初始化栈
	S.base = new char[MAXSIZE];
	if (!S.base) return OVERFLOW;
	S.top = S.base;
	S.stacksize = MAXSIZE;
	return OK;
}

Status Push(SqStack& S, char e)
{//入栈
	if (S.top - S.base == S.stacksize)  //栈满
		return ERROR;
	*S.top = e;
	S.top++;
	return OK;
}

Status Pop(SqStack& S)
{//出栈
	if (S.top == S.base)   //栈空
		return ERROR;
	S.top--;
	return OK;
}

char GetTop(SqStack S)
{//取栈顶元素
	if (S.top != S.base)
		return *(S.top - 1);
	return ERROR;
}

char Precede(char a, char b)
{//比较符号优先级
	if ((a == '(' && b == ')') || (a == '=' && b == '='))
		return '=';
	else if (a == '=' || a == '(' || b == '(' || ((a == '+' || a == '-') && (b == '*' || b == '/')))
		return '<';
	else
		return '>';
}


void InfixToSuffix(SqStack op, char s[])
{//将中缀表达式转化为后缀表达式并输出 
	/**************begin************/
	int i = 0;
	while ((s[i] != '=' || GetTop(op) != '=') && s[i] != '\0') {		//循环截止条件

		//遇到操作数，直接加入后缀表达式(即输出)
		if (s[i] >= '0' && s[i] <= '9') {
			cout << s[i];
			i++;
			continue;
		}
		//遇到界限符 ( ，直接入栈 
		else if (s[i] == '(')
		{
			Push(op, s[i]);
			i++;
			continue;
		}
		//遇到界限符 ) ,依次出栈，直到弹出 ( 
		else if (s[i] == ')')
		{
			while (*(op.top - 1) != '(')
			{
				cout << GetTop(op);
				Pop(op);
			}
			Pop(op);
			i++;
			continue;
		}
		//遇到运算符，依次弹出栈中运算优先级大于等于自己的运算符
		//遇到 ( 或者 栈空 停止，之后把自己入栈 
		else if (s[i] == '+' || s[i] == '-' || s[i] == '*' || s[i] == '/')
		{
			if (s[i] == '+' || s[i] == '-')
			{
				while (op.top - op.base != 1 && *(op.top - 1) != '(')
				{
					cout << GetTop(op);
					Pop(op);
				}
			}
			else
			{
				while (op.top - op.base != 1 && *(op.top - 1) != '(' && *(op.top - 1) != '+' && *(op.top - 1) != '-')
				{
					cout << GetTop(op);
					Pop(op);
				}
			}
			Push(op, s[i]);
			i++;
			continue;
		}
		while (op.top - op.base != 1)
		{
			cout << GetTop(op);
			Pop(op);
		}
	}
	cout << endl;

	/**************end************/
}


int main()
{
	SqStack op;
	InitStack(op);      //初始化字符栈op
	Push(op, '=');		//先在栈底放入'='便于以后比较符号优先级	
	char s[100];
	while (cin >> s)
	{
		if (s[0] == '=')
			break;    	//当表达式只有一个“=”时，输入结束 
		else
			InfixToSuffix(op, s); 	//将中缀表达式转化为后缀表达式并输出	
	}
	return 0;
}

按注释所给提示，依次进行操作即可，解题思路相对固定

第十三关：基于循环链表的队列的基本操作

本关任务：用带头结点的循环链表表示队列，并且只设一个指针指向队尾元素结点（不设头指针）。实现该队列的入队出队以及判断队列是否为空操作。
输入：多组数据，每组数据有两行。第一行为两个整数n和m，n表示入队序列A的长度（n个数依次连续入队，中间没有出队的情况），m表示出队序列B的元素数量（m个数依次连续出队，中间没有入队的情况）。第二行为序列A（空格分隔的n个整数）。当n和m都等于0时，输入结束。
输出：对应每组数据输出一行。每行包括m+1个整数，前m个数代表出队序列B的各个整数，最后一个整数表示队列是否为空，队列为空输出0，不为空输出1。整数之间用空格分隔。

测试输入：
5 3
1 3 5 3 6
4 4
-1 2 3 4
0 0

预期输出：
1 3 5 1
-1 2 3 4 0

#include<iostream>
using namespace std;

typedef struct QNode
{//队列的链式存储结构
	int data;
	struct QNode* next;
}QNode, * QueuePtr;

typedef struct
{
	QueuePtr rear;    //只设一个队尾指针
}LinkQueue;


int EmptyQueue(LinkQueue Q)
{//判断队列是否为空，空返回1，否则返回0
//队列只有一个头结点，即当头结点的指针域指向自己时，队列为空
	/**************begin************/
	if (Q.rear->next == Q.rear) return 1;
	return 0;
	/**************end************/
}


void EnQueue(LinkQueue& Q, int e)
{//入队，插入元素e为Q的新的队尾元素
	/**************begin************/
	QueuePtr queuePtr = new QNode();
	queuePtr->data = e;
	queuePtr->next = Q.rear->next;
	Q.rear->next = queuePtr;
	Q.rear = Q.rear->next;
	/**************end************/
}


void DeQueue(LinkQueue& Q)
{//出队，输出Q的队头元素值，后将其删除
	/**************begin************/
	QueuePtr q = Q.rear->next->next;
	cout << q->data << ' ';
	Q.rear->next->next = q->next;
	if (q == Q.rear) {
		Q.rear = Q.rear->next;
	}
	/**************end************/
}


int main()
{
	int n, m;
	while (cin >> n >> m)
	{
		if (n == 0 && m == 0) break;
		LinkQueue Q;        //初始化一个带头结点的循环链表
		Q.rear = new QNode;
		Q.rear->next = Q.rear;
		while (n--)
		{
			int e; cin >> e;
			EnQueue(Q, e);
		}
		while (m--)
			DeQueue(Q);
		if (EmptyQueue(Q))
			cout << "0" << endl;
		else
			cout << "1" << endl;
	}
	return 0;
}

第十四关：附加判定标志的循环队列的基本操作

本关任务：假设以数组Q[m]存放循环队列中的元素, 同时设置一个标志tag，以tag== 0和tag == 1来区别在队头指针(front)和队尾指针(rear)相等时，队列状态为“空”还是“满”。试编写与此结构相应的插入(enqueue)和删除(dlqueue)算法。
输入：多组数据，每组数据有两行。第一行为一个整数n，n表示入队序列A的长度（n个数依次连续入队，中间没有出队的情况），第二行为序列A（空格分隔的n个整数）。当n=0时，输入结束。
输出：对应每组数据输出一行。依次输出队列中所有的整数，每两个整数之间用空格分隔。

测试输入：
4
1 2 3 4
5
1 2 4 5 3
0

预期输出：
1 2 3 4
1 2 4 5 3

#include<iostream>
using namespace std;
#define MAXSIZE 100
#define OK 0
#define OVERFLOW -1
#define ERROR -2

typedef struct
{
	int* base;
	int front, rear, tag;
}SqQueue;

int InitQueue(SqQueue& Q)
{//构造一个空队列Q
	Q.base = new int[MAXSIZE];//为队列分配一个最大容量MAXSIZE的数组空间
	if (!Q.base) return OVERFLOW;//存储分配失败
	Q.front = Q.rear = 0;//头尾指针置零，队列为空
	Q.tag = 0;//标志初始化为0，队列为空
	return OK;
}


int EnQueue(SqQueue& Q, int e)
{//插入元素e为Q的新的队尾元素
/**************begin************/
	if ((Q.rear + 1) % MAXSIZE == Q.front) return ERROR;	//判断队列是否满
	Q.base[Q.rear] = e;
	Q.rear = (Q.rear + 1) % MAXSIZE;
	return OK;

	/**************end************/
}


int DeQueue(SqQueue& Q)
{//删除Q的队头元素，用e返回其值
/**************begin************/
	if (Q.front == Q.rear) return ERROR;		//判断队列是否空
	int e = Q.base[Q.front];
	Q.front = (Q.front + 1) % MAXSIZE;
	return e;

	/**************end************/
}


int main()
{
	int n;
	while (cin >> n)
	{
		if (n == 0) break;
		SqQueue Q;
		InitQueue(Q);
		for (int i = 0; i < n; i++)
		{
			int x; cin >> x;
			EnQueue(Q, x);
		}
		for (int i = 0; i < n - 1; i++)
			cout << DeQueue(Q) << " ";
		cout << DeQueue(Q) << endl;
	}
	return 0;
}

第十五关：基于两端操作的循环队列的实现

本关任务：如果允许在循环队列的两端都可以进行插入和删除操作。构造一个循环队列，实现从队头入队，从队尾出队并输出。约定从队头入队时向下标小的方向发展，从队尾入队时则向下标大的方向发展。
输入：多组数据，每组数据有两行。第一行为一个整数n，n表示入队序列A的长度（n个数依次连续入队，中间没有出队的情况），第二行为序列A（空格分隔的n个整数）。当n等于0时，输入结束。
输出：
对应每组数据输出一行。依次输出队列中所有的整数，每两个整数之间用空格分隔。

测试输入：
5
1 2 3 4 5
2
1 4
0

预期输出：
1 2 3 4 5
1 4

#include<iostream>
using namespace std;
#define MAXSIZE 100
#define OK 1
#define ERROR 0
#define OVERFLOW -2

typedef struct
{
	int* base;
	int front;
	int rear;
}SqQueue;

int InitQueue(SqQueue& Q)
{//构造一个空队列Q
	Q.base = new int[MAXSIZE];          //为队列分配一个最大容量为MAXSIZE的数组空间
	if (!Q.base) return OVERFLOW;            //存储分配失败
	Q.front = Q.rear = 0;                  //头尾指针置零，队列为空
	return OK;
}


int EnQueue(SqQueue& Q, int e)
{//在Q的队头插入新元素e
/**************begin************/
	if ((Q.rear + 1) % MAXSIZE == Q.front) return ERROR;
	Q.base[Q.rear] = e;
	Q.rear = (Q.rear + 1) % MAXSIZE;
	return OK;

	/**************end************/
}


int DeQueue(SqQueue& Q)
{//删除Q的队尾元素，用e返回其值
/**************begin************/
	if (Q.front == Q.rear) return ERROR;
	int e = Q.base[Q.front];
	Q.front = (Q.front + 1) % MAXSIZE;
	return e;

	/**************end************/
}


int main()
{
	int n;
	while (cin >> n && n != 0)
	{
		SqQueue Q;
		InitQueue(Q);
		for (int i = 0; i < n; i++)
		{
			int x; cin >> x;
			EnQueue(Q, x);
		}
		for (int i = 0; i < n - 1; i++)
			cout << DeQueue(Q) << " ";
		cout << DeQueue(Q) << endl;
	}
	return 0;
}