编程题实训-栈2

第7关：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+1;
    }else if(m > 0 && n == 0){
        return Ack(m-1,1);
    }else{
        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;
}

第8关：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 tmp[m + 1][MAXSIZE];
    for (int j = 0; j < MAXSIZE; j ++)
        tmp[0][j] = j + 1;
    for (int i = 1; i <= m; i ++)
    {
        tmp[i][0] = tmp[i - 1][1];
        for (int j = 1; j < MAXSIZE; j ++)
            tmp[i][j] = tmp[i - 1][tmp[i][j - 1]];
    }
    
    return (tmp[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;
}

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

任务描述

本关任务：利用单链表表示一个整数序列，利用递归的方法求出单链表中整数的最大值。

编程要求

输入

多组数据，每组数据有两行，第一行为链表的长度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;
}

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

任务描述

本关任务：利用单链表表示一个整数序列，利用递归的方法计算单链表中结点的个数。

编程要求

输入

多组数据，每组数据有两行，第一行为链表的长度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) return 1;  //L指向表尾，返回1
    else return GetLength(L->next)+1;    //每递归一次，结点数加1
 



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

第11关：递归求解单链表中的平均值

任务描述

本关任务：利用单链表表示一个整数序列，利用递归的方法计算单链表中各个结点的平均值。

编程要求

输入

多组数据，每组数据有两行，第一行为链表的长度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) return L->data;    //L指向表尾，返回其数值
    else
    {
        double ave=GetAverage(L->next,n-1);  //递归求解除尾结点外的其余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;
}

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

任务描述

本关任务：输入一个中缀算术表达式，将其转换为后缀表达式。运算符包括+、-、*、/、(、)、=，参加运算的为小于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************/
	for (int i = 0; s[i] != '\0'; i++) {  
        if ('0' <= s[i] && s[i] <= '9') {  
            cout << s[i]; // 如果是数字，则直接输出  
        } else {  
            while (1) {  
                if (Precede(GetTop(op), s[i]) == '<') {  
                    Push(op, s[i]); // 如果栈顶操作符优先级小于当前操作符，将当前操作符压入栈中  
                    break;  
                } else if (Precede(GetTop(op), s[i]) == '>') {  
                    cout << GetTop(op); // 如果栈顶操作符优先级大于当前操作符，输出栈顶操作符并弹出  
                    Pop(op);  
                } else {  
                    Pop(op); // 如果栈为空，弹出栈中所有操作符  
                    break;  
                }  
            }  
        }  
    }  
    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;
}