1.递归计算n!（10分）
题目内容：
编写递归函数，计算n!。在主函数中输入n，调用函数计算n！，在主函数中输出n!。
输入:非负整数。
输出：整数。
【注意】应用递归函数实现，否则没有意义。
样例1输入：
6
样例1输出：
720
时间限制：500ms内存限制：32000kb
#include <iostream>
using namespace std;
int f(int n)
{
if(n==0||n==1) return 1;
return n*f(n-1);
}
int main()
{
int n;
cin>>n;
cout<<f(n)<<endl;
return 0;
}
2.递归计算1+2+3+…+n（10分）
题目内容：
编写递归函数，计算1+2+3+…+n。在主函数中输入n，调用函数计算1到n的和，在主函数中输出和。
输入:非负整数。
输出：非负整数。
【注意】应用递归函数实现，否则没有意义。输入0时，和为0.
样例1输入：
10
样例1输出：
55
时间限制：500ms内存限制：32000kb
#include <iostream>
using namespace std;
int sum(int n)
{
if(n==0) return 0;
return n+sum(n-1);
}
int main()
{
int n;
cin>>n;
cout<<sum(n)<<endl;
return 0;
}
3.递归求数组元素的最大值（10分）
题目内容：
编写递归函数，求数组元素的最大值，函数的输入参数为数组和元素个数，返回最大值。在主函数中输入元素个数和数组元素，调用函数求最大值，在主函数中输出结果。设数组类型为整型，元素不超过100个。
输入:元素个数n和n个元素，用空格或换行隔开。
输出：数组元素最大值。
【注意】使用递归，否则没有意义。
样例1输入：
6
12 1 2 3 14 6
样例1输出：
14
时间限制：500ms内存限制：32000kb
#include <iostream>
using namespace std;
int mymax(int data[], int n)//前n-1个元素里的最大值与当前元素比较，选大的值
{
if(n==0) return data[0];
int m = mymax(data, n-1);
if(m<data[n-1]) m = data[n-1];
return m;
}
int main()
{
int n;
int a[100];
cin>>n;
for(int i=0; i<n; i++)
cin>>a[i];
int m = mymax(a,n);
cout<<m<<endl;
return 0;
}
4.递归求数组元素的和（10分）
题目内容：
编写递归函数，求数组元素的和，函数的输入参数为数组和元素个数，返回最大值。在主函数中输入元素个数和数组元素，调用函数求和，在主函数中输出结果。设数组类型为整型，元素不超过100个。
输入:元素个数n和n个元素，用空格或换行隔开。
输出：数组元素和。
【提示】元素个数为0时返回和是0.
样例1输入：
6
1 2 3 4 5 6
样例1输出：
21
时间限制：500ms内存限制：32000kb
#include <iostream>
using namespace std;
int sum(int data[], int n)//前n-1个元素的和加上当前元素
{
if(n==0)
return 0;
return sum(data,n-1)+data[n-1];
}
int main()
{
int a[110];
int n;
cin>>n;
for(int i=0; i<n; i++)
cin>>a[i];
cout<<sum(a,n)<<endl;
return 0;
}
5.递归求Fibonacci序列的第n项（10分）
题目内容：
Fibonacci（费波那契）序列:
f(0)=0
f(1)=1
f(n)=f(n-1)+f(n-2),n=2,3,4,…
编写递归函数，计算Fibonacci序列的第n项（n=0,1,2,3,…）。在主函数中输入n，调用函数计算Fibonacci第n项，在主函数中输出结果。
输入:非负整数
输出：非负整数
【注意】应用递归函数实现。
样例1输入：
6
样例1输出：
8
时间限制：1000ms内存限制：32000kb
#include <iostream>
using namespace std;
int f(int n)
{
if(n==0) return 0;
if(n==1) return 1;
return f(n-1)+f(n-2);
}
int main()
{
int n;
cin>>n;
cout<<f(n)<<endl;
return 0;
}
6.递归逆序数组元素（10分）
题目内容：
编写递归函数，将数组元素逆序，函数的输入参数是数组、起始下标和元素个数。在主函数中输入元素个数和数组元素，调用函数逆序，在主函数中输出结果。设数组类型为整型，元素不超过100个。
输入:元素个数n和n个元素，用空格或换行隔开。
输出：逆序的数组元素，用一个空格隔开，末尾无空格。
【提示】本函数不需返回值。
【注意】必须用递归函数实现，否则没有意义。
样例1输入：
5
1 2 3 4 5
样例1输出：
5 4 3 2 1
时间限制：500ms内存限制：32000kb
#include <iostream>
using namespace std;
void swap(int &a, int &b)
{
int temp = a;
a = b;
b = temp;
}
void reverse(int a[], int left, int len)//首尾元素交换，直至剩下一个元素
{
if(len==1||len==0) return;
swap(a[left], a[left+len-1]);
reverse(a, left+1, len-2);
}
int main()
{
int a[100];
int n;
cin>>n;
for(int i=0; i<n; i++)
cin>>a[i];
reverse(a,0,n);
cout<<a[0];
for(int i=1; i<n; i++)
cout<<" "<<a[i];
cout<<endl;
return 0;
}
7.输入输出数组元素的函数重载（10分）
题目内容：
函数重载就是定义函数名相同，参数类型或参数个数不同的函数。这些函数称为重载函数。具有重载关系的函数一般具有相同或相似的功能，但作用的对象不同。
编写输入数组元素的重载函数，数组类型分别为int和double，输入-9999时结束输入，返回输入的元素个数。编写输出数组元素的重载函数，数组类型分别为int和double。编写主函数，定义数组，调用函数输入元素，调用函数输出元素。元素个数不超过100个。主函数如下：
见代码
输入:两行。第1行为整型数组元素，第2行为double数组元素，均以-9999表示结束。
输出：两行，第1行为整型数组元素，第2行为double数组元素，以一个空格分隔，末尾无空格。
【提示】print函数中最后输出一个换行。
【注意】不使用重载，无意义。需提交完成程序。
样例1输入：
1 2 3 4 5 6 7 -9999
1.1 1.2 1.3 1.5 1.6 1.6 1.7 1.8 1.9 -9999
样例1输出：
1 2 3 4 5 6 7
1.1 1.2 1.3 1.5 1.6 1.6 1.7 1.8 1.9
时间限制：500ms内存限制：32000kb
#include <iostream>
using namespace std;
int input(int a[]);
int input(double a[]);
void print(int a[], int len);
void print(double a[], int len);
int main()
{
int a[100];
double b[100];
int lena = input(a);
int lenb = input(b);
print(a,lena);
print(b,lenb);
return 0;
}
int input(int a[])
{
int num;
int i = 0;
do //可用while语句替换
{
cin>>num;
if(num!=-9999)
a[i++] = num;//先填入元素，再加一
}while(num!=-9999);
return i;//i刚好是数组元素个数
}
int input(double a[])
{
double num;
int i = 0;
do
{
cin>>num;
if(num!=-9999)
a[i++] = num;
}while(num!=-9999);
return i;
}
void print(int a[], int len)
{
cout<<a[0];
for(int i=1; i<len; i++)
cout<<" "<<a[i];
cout<<endl;
}
void print(double a[], int len)
{
cout<<a[0];
for(int i=1; i<len; i++)
cout<<" "<<a[i];
cout<<endl;
}
8.逆序函数重载（10分）
题目内容：
编写逆序数组元素的重载函数，数组元素类型分别为int和double。编写主函数，定义数组，可以调用上题的函数输入数组元素，调用逆序函数逆序数组元素，可以调用上题函数输出数组元素。注意，不能在逆序函数中输出。数组元素个数不超过100个。主函数如下：
输入:两行。第1行为整型数组元素，第2行为double数组元素，均以-9999表示结束。
输出：两行，第1行为逆序的整型数组元素，第2行为逆序的double数组元素，以一个空格分隔，末尾无空格。
【提示】print函数中最后输出一个换行。
【注意】不使用重载，无意义。
样例1输入：
1 2 3 4 5 6 7 8 -9999
1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 1.9 -9999
样例1输出：
8 7 6 5 4 3 2 1
1.9 1.8 1.7 1.6 1.5 1.4 1.3 1.2 1.1
时间限制：500ms内存限制：32000kb
#include <iostream>
using namespace std;
int input(int a[]);
int input(double a[]);
void reverse(int a[], int len);
void reverse(double a[], int len);
void print(int a[], int len);
void print(double a[], int len);
int main()
{
int ai[100];
double ad[100];
int ni, nd;
ni = input(ai);
nd = input(ad);
reverse(ai,ni);
reverse(ad,nd);
print(ai,ni);
print(ad,nd);
return 0;
}
int input(int a[])
{
int num;
int i=0;
do
{
cin>>num;
if(num!=-9999)
a[i++] = num;
}while(num!=-9999);
return i;
}
int input(double a[])
{
double num;
int i=0;
do
{
cin>>num;
if(num!=-9999)
a[i++] = num;
}while(num!=-9999);
return i;
}
void reverse(int a[], int len)//转置函数没用递归，因为递归复杂度比较高
{
for(int i=0; len>1; i++)//首尾交换，思路与上面相同
{
int temp = a[i];
a[i] = a[i+len-1];
a[i+len-1] = temp;
len-=2;
}
}
void reverse(double a[], int len)
{
for(int i=0; len>1; i++)
{
double temp = a[i];
a[i] = a[i+len-1];
a[i+len-1] = temp;
len-=2;
}
}
void print(int a[], int len)
{
cout<<a[0];
for(int i=1; i<len; i++)
cout<<" "<<a[i];
cout<<endl;
}
void print(double a[], int len)
{
cout<<a[0];
for(int i=1; i<len; i++)
cout<<" "<<a[i];
cout<<endl;
}
9.数组元素求和函数的重载（10分）
题目内容：
编写数组元素求和的重载函数，数组元素类型分别为int和double。编写主函数，定义数组，可以调用前面的函数输入数组元素，调用求和函数求和，在主函数中输出结果。数组元素个数不超过100个。主函数如下：
输入:两行。第1行为整型数组元素，第2行为double数组元素，均以-9999表示结束。
输出：一个整数和，一个实数和，用空格隔开。
【注意】不使用重载，无意义。
样例1输入：
1 2 3 4 5 6 7 8 9 10 -9999
1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 1.9 -9999
样例1输出：
55 13.5
时间限制：500ms内存限制：32000kb
#include <iostream>
using namespace std;
int input(int a[]);
int input(double a[]);
int mysum(int a[], int len);
double mysum(double a[], int len);
int main()
{
int ai[100];
double ad[100];
int sumi;
double sumd;
int ni=input(ai);
int nd=input(ad);
sumi = mysum(ai,ni);
sumd = mysum(ad,nd);
cout<<sumi<<" "<<sumd<<endl;
return 0;
}
int input(int a[])
{
int i=0;
int num;
do
{
cin>>num;
if(num!=-9999)
a[i++] = num;
}while(num!=-9999);
return i;
}
int input(double a[])
{
int i=0;
double num;
do
{
cin>>num;
if(num!=-9999)
a[i++] = num;
}while(num!=-9999);
return i;
}
int mysum(int a[], int len)
{
int sum = 0;
for(int i=0; i<len; i++)
sum += a[i];
return sum;
}
double mysum(double a[], int len)
{
double sum = 0;
for(int i=0; i<len; i++)
sum += a[i];
return sum;
}
10.交换两个元素值的重载函数（10分）
题目内容：
编写交换两个元素值的重载函数，两个元素会是两个整数、两个实数、两个整型数组、两个char型字符串。编写主函数，定义有关变量、数组，输入数据，调用函数，输出交换结果。数组元素不超过100。主函数如下 (其中print(是前面编写的显示数组元素的函数)：
输入:5行；分别是两整数，两实数，数组1，数组2，两个字符串。见样例输入。其中数组行的第1个数是元素个数。
输出：5行，交换的结果，见样例输出。
【注意】不能使用系统的字符串处理库函数，不使用string。可以自定义需要的函数。
【提示】整数、实数的交换使用参数的引用传递；数组的交换，元素个数的交换使用引用传递。
样例1输入：
2 3
1.2 1.81
3 1 2 3
8 81 82 83 84 85 86 87 88
input output
样例1输出：
3 2
1.81 1.2
81 82 83 84 85 86 87 88
1 2 3
output input
时间限制：500ms内存限制：32000kb
#include <iostream>
using namespace std;
void swap(int &a, int &b);
void swap(double &a, double &b);
void swap(int a[], int &lena, int b[], int &lenb);
void swap(char st1[], char st2[]);
void print(int a[], int len);
void print(double a[], int len);
int main()
{
int a, b;
double da, db;
int aa[100], ab[100];
char s1[100], s2[100];
int n, m;
int i;
//输入
cin>>a>>b;
cin>>da>>db;
//输入数组
cin>>n;
for(i=0; i<n; i++)
{
cin>>aa[i];
}
cin>>m;
for(i=0; i<m; i++)
{
cin>>ab[i];
}
cin>>s1>>s2;
//交换
swap(a,b);
swap(da,db);
swap(aa,n,ab,m);
swap(s1,s2);
//输出
cout<<a<<" "<<b<<endl;
cout<<da<<" "<<db<<endl;
print(aa,n);
print(ab,m);
cout<<s1<<" "<<s2<<endl;
return 0;
}
void swap(int &a, int &b)//用的引用，没有用指针
{
int temp = a;
a = b;
b = temp;
}
void swap(double &a, double &b)
{
double temp = a;
a = b;
b = temp;
}
void swap(int a[], int &lena, int b[], int &lenb)//要交换实际的值
{
int maxLen = lena;
if(maxLen<lenb) maxLen = lenb;//选最大的数组长度，可以用库函数
for(int i=0; i<maxLen; i++)
swap(a[i], b[i]);
swap(lena,lenb);//交换完数组后，要交换数组长度
}
void swap(char st1[], char st2[])
{
char *p = st1;
char *q = st2;
while(*p||*q)//和交换数组时思路一样，两种表达方式，都表示用最大长度
{
char ch = *p;
*p = *q;
*q = ch;
p++;
q++;
}
*p = 0;//交换完成之后，把字符串末尾变成0
*q = 0;
}
void print(int a[], int len)
{
cout<<a[0];
for(int i=1; i<len; i++)
cout<<" "<<a[i];
cout<<endl;
}
void print(double a[], int len)
{
cout<<a[0];
for(int i=1; i<len; i++)
cout<<" "<<a[i];
cout<<endl;
}
