递归基本概念

1. 函数递归*
编写一个函数，使用递归算法求满足下述定义的整数序列的第n项。

1 当 n >= 0 且 n <= 4 时
f( n ) = f(n-1) + f(n-3) 当 n > 4 且n为偶数 时
f(n-2) + f(n-4) 当 n > 4 且n为奇数 时
-1 其他

函数原型如下：

int findf(int n);

参数说明：n 项数；返回值是第n项值。
例如输入：10，输出：8

#include <stdio.h>  
  
int findf(int n)  
{  
    int m;  
    if(n>=0&&n<=4)  
    {  
        m = 1;  
        return m;  
    }  
    if(n>4&&n%2==0)  
    {  
        m = findf(n-1)+findf(n-3);  
        return m;  
    }  
    if(n>4&&n%2!=0)  
    {  
        m = findf(n-2)+findf(n-4);  
        return m ;  
    }  
    else  
    {  
        m = -1;  
        return m;  
    }  
      
}  

2. 求解平方根
小明上来大学，学习了用求解平方根的迭代公式。

其中：p 为 x 的近似平方根，e 是结果允许的误差。

输入：x, e

输出：p 保留小数点后 8 位。

#include <stdio.h>  
#include <math.h>  
double jintian(double , double , double );  
int main(int argc, char** argv) {  
    double a, wucha, b, p;  
    scanf("%lf%lf", &a, &wucha);  
 b = sqrt(a);  
    p =jintian(a,wucha,b);  
    printf("%.8lf\n", p);  
}  
double jintian(double a, double wucha, double b)  
{  
    double p;  
    p = fabs(b*b-a);  
    if(p<wucha)  
    {  
        return b;  
    }  
    else   
    {  
        jintian( a, wucha, 1/2*(b+b/a));  
        return b;  
    }  
}  

3. 求最大公约数——递归
请使用递归算法计算正整数n和m的最大公约数GCD(n,m)。

= m 当 m<=n 且 n mod m =0
GCD(N,M) = GCD(m,n) 当n<m时
= GCD(m, n mod m) 其他

输入：
n和m

输出：
n和m的最大公约数

#include <stdio.h>  
int yue(int,int);  
int main(int argc, char** argv) {  
    int a, b, c;  
    scanf("%d%d", &a, &b);  
    c = yue(a,b);  
    printf("%d\n", c);  
}  
int yue(int a, int b)  
{  
    int c;  
    if(a>b)  
    {  
        if(a%b==0)  
        {  
            return b;  
        }  
        else   
        {   c = a%b;  
            return yue(c, b);  
        }  
    }  
    else  
    {  
            if(b%a==0)  
        {  
            return a;  
        }  
        else   
        {   c = b%a;  
            return yue(a, c);  
        }  
    }  
}  

4. 回文字符串——递归
有一种特殊形式的字符串，其正反序相同，被称为"回文字符串”。例如LeveL就是一个回文字符串。

输入：
字符串

输出：
Yes或者No

说明：
如输出Yes，说明输入的字符串是一个回文字符串
输出No，说明输入的字符串不是一个回文字符串
请使用递归算法实现。

强烈建议：编写一个递归函数，用函数的返回值标示是否为回文字符串。

#include<stdio.h>  
#include<string.h>  
int labor(char str[])  
{int i;   
    for(i=0;i<=strlen(str)/2;i++)  
    {if(str[i]!=str[strlen(str)-1-i]){return 0;}  
    }  
    return 1;  
}  
int main()  
{  
    char a[100000];  
    gets(a);  
    if(labor(a)==0)  
    {printf("No\n");  
    }  
    else  
    {printf("Yes\n");  
    }  
}  

5. 小数相乘
给定2个小数，每个小数均小于10000；每个小数最多到小数点后50位。

输入：a
b
输出：a*b

#include <iostream>   
#include <string>   
using namespace std;   
string mul(string, string);   
int main()   
{   
string sMul,sMul1,sRes;   
//以上依次为，乘数，当前结果   
int iDot,iLen,iLen1,iTmp,iTmp1,i;  
int iExp;  
//以上依次分别为指数，小数点在结果中的位置，被处理过的乘数的当前长度，临时变量，循环变量   
  
while(cin>>sMul>>sMul1)  
  
{   
  
iLen = sMul.length();   
  
   
  
iTmp = sMul.find_last_not_of("0"); //从尾端查找第一个非0数的位置   
  
if (iTmp < iLen-1) //如果这个位置不是乘数的末位（换言之这个乘数小数部分末尾有0）   
  
{   
  
  sMul.erase(iTmp+1,iLen-iTmp); //剔除乘数小数部分末尾的0   
  
  iLen = sMul.length(); //更新iLen的值   
  
}   
  
   
  
iLen1=sMul1.length();  
  
iTmp1=sMul1.find_last_not_of("0");  
  
if(iTmp1<iLen-1)  
  
{  
  
    sMul1.erase(iTmp1+1,iLen1-iTmp1);  
  
    iLen1=sMul1.length();  
  
}  
  
iTmp=sMul.find_first_of(".");  
  
iTmp1=sMul1.find_first_of(".");  
  
iDot=iTmp+iTmp1-1;  
  
sMul.erase(iTmp,1); //剔除被乘数的"."   
  
sMul1.erase(iTmp1,1);  
  
   
  
while (sMul[0]=='0')   
  
sMul.erase(0,1); //这个循环剔除乘数前面的0   
  
sRes=sMul;   
  
sRes=mul(sMul,sMul1);  
  
   
  
while (sRes.length()<iDot)   
  
sRes='0'+sRes; //这个循环用来为结果补0，以添加小数点   
  
if (iDot!=0)   
  
sRes.insert(iDot,".");  
  
cout << sRes << endl;   
  
}   
  
return 0;   
  
}   
  
   
  
string mul(string a,string b)   
  
{   
  
string sRes=""; //先置结果为空   
  
int la,lb,i,j,temp1,temp2;   
  
//以上依次为乘数a/b的长度，两个循环变量，两个中间变量   
  
   
  
la=a.length();lb=b.length();   
  
for (i=0;i<la+lb;i++)   
  
sRes.insert(0,"0"); //根据结果的最大长度置0   
  
   
  
for (i=lb-1;i>=0;i--)   
  
{   
  
temp1=0;   
  
for (j=la-1;j>=0;j--)   
  
{   
  
temp1+=(b[i]-48)*(a[j]-48);   
  
temp2=sRes[i+j+1]-48+temp1%10;   
  
sRes[i+j+1]=temp2%10+48;   
  
temp1=temp1/10+temp2/10;   
  
}   
  
sRes[i]=temp1+48;   
  
}   
  
//以上过程就是模拟计算   
  
while (sRes[0]=='0')   
  
sRes.erase(0,1); //循环剔除结果前面的0   
  
return sRes;   
  
}