必须掌握的算法之一 —— 递归算法

递归算法总结

递归的定义

在调用一个函数的过程中又出现直接或间接调用该函数本身，称为函数的递
归(Recursion)调用，这种函数称为递归函数

• 若p函数定义中调用p函数，称之为直接递归
• 若p函数定义中调用q函数，而q函数定义中又调用p函数，称之为间接递归

递归要素

• 递归表达式（递归方程）
• 递归结束条件（边界条件）
  1-100求和
  

递归树

典型递归实例

• 求阶乘
  
• Fibonacci数列
  
  

用递归解决问题应满足的条件

• 需要解决的问题可以转化为一个或多个子问题来求解，而这些子问题的求解方法与原问题完全相同,只是在数量规模上不同
• 递归调用的次数必须有限
• 必须有结束递归的条件来终止递归

使用递归的条件

• 定义是递归的（阶乘、斐波那契数列等）
• 数据结构是递归的（单链表、二叉树等）
• 问题的求解方法是递归的（汉诺塔、回溯法等）

递归特点

优点：结构清晰，可读性强，而且容易用数学归纳法来证明算法的正确性，因此它为设计算法、调试程序带来很大方便
缺点：递归算法的运行效率较低，无论是耗费的计算时间还是占用的存储空
间都比非递归算法要多
解决方法：在某些递归算法中可消除递归调用，使其转化为非递归算法

典型实例之汉诺塔

游戏规则

A, B, C 3根柱子，n个圆盘，自下而上，由大到小, 将这n个圆盘从A柱移动到C柱，并且在C柱也需要按照从下往上由大到小的顺序叠放
在移动圆盘时应遵守以下移动规则：

• 规则1：每次只能移动1个圆盘
• 规则2：任何时刻都不允许将较大的圆盘压在较小的圆盘之上
• 规则3：在满足移动规则1和2的前提下，可将圆盘移至A，B，C中任一根柱子上

游戏思路
1个盘子：A–>C,一步完成；
2个盘子：小圆盘 A–>B,大圆盘 A–>C,小圆盘 B–>C,三步完成；
3个盘子：
①将两个圆盘由A柱移到B柱（3步完成），
② 将最下面的圆盘由A柱移到C柱（1步完成），
③将两个圆盘由B柱移到C柱（3步完成），
共7步完成
伪代码

代码实现

#include 
int step;//默认为0，也可以自己定义为step=0；
void move(int n, char a, char b)
{
     
    printf("%d: move %d from %c to %c.\n", ++step, n, a, b);
}
void hanoi(int n, char a, char b, char c)
{
     
    if (n > 0)
    {
     
        hanoi(n-1, a, c, b);
        move(n,a,c);
        hanoi(n-1, b, a, c);
    }
}

int main()
{
     
    int n;
    scanf("%d",&n);
    hanoi(n,'A','B','C');//从A移动到C借助B
}

递归算法——例题

递归计数

题目描述
编写一个递归程序，返回一个字符串中大写字母的数目。例如，输入“AbcD”，输出2。
输入
多组输入，每组包括一个仅由大小写字母组成的字符串。
输出
输出字符串中出现大写字母的数目。
样例输入
AbcD
样例输出
2

AC代码

#include 
using namespace std;
int sum;
char a[100];
int fun(int n)
{
     
    if(a[n]>='A'&&a[n]<='Z')
    {
     
        sum+=1;
    }
    if(n>0)
    {
     
        fun(n-1);
    }
    return sum;
}
int main()
{
     
 
    while(~scanf("%s",a))
    {
     
        sum=0;
        int len=strlen(a);
        printf("%d\n",fun(len-1));
    }
   

骨牌覆盖

题目描述
用大小为1×2的骨牌铺满一个大小为2×n的长方形方格，编写一个程序，输入n，输出铺放方案总数。例如，输入n=3，即大小为2×3的方格，输出3。3种骨牌铺放方案如下图所示：

输入
多组测试用例，每一组是一个正整数。
输出
每组输出占一行。
只需要输出铺放方案总数，不需要输出具体的铺放方案。
样例输入
3
样例输出
3

AC代码

#include 
using namespace std;
 
int fun(int n)
{
     
    if(n==1) return 1;
    if(n==2) return 2;
    return fun(n-2)+fun(n-1);
}
int main()
{
     
    int n;
    while(~scanf("%d",&n))
    {
     
        printf("%d\n",fun(n));
    }
    return 0;
}

蜂房

题目描述
有一只经过训练的蜜蜂只能爬向右侧相邻的蜂房，不能反向爬行。请编程计算蜜蜂从蜂房a爬到蜂房b的可能路线数。
其中，蜂房的结构如下所示。

输入
多组数据输入，每组数据包含两个正整数a, b，且 a 输出
蜜蜂从蜂房a爬到蜂房b的可能路线数。
样例输入
1 2
3 4
样例输出
1
1

AC代码

#include 
using namespace std;
 
int fun(int n)
{
     
    if(n==1) return 1;
    if(n==2) return 1;
    return fun(n-2)+fun(n-1);
}
int main()
{
     
    int a,b;
    while(~scanf("%d %d",&a,&b))
    {
     
        printf("%d\n",fun(b-a+1));
    }
    return 0;
}

斐波那契数

题目描述
Kimi号称自己已经记住了1-100000之间所有的斐波那契数。
为了考验他，我们随便出一个数n，让他说出第n个斐波那契数。
当然，斐波那契数会很大。
因此，如果第n个斐波那契数不到6位，则说出该数；否则只说出最后6位(无需输出前导0)。
输入
输入有多组数据。
每组数据一行，包含一个整数n (1≤n≤100000)。
输出
对应每一组输入，输出第n个斐波那契数的最后6位。
样例输入
1
2
3
4
100000
样例输出
1
2
3
5
537501

AC代码

#include 
using namespace std;
int main()
{
     
    int n;
    int a[100005];
    a[0]=1;
    a[1]=1;
    for(int i=2;i<=100005;i++)
    {
     
        a[i]=a[i-1]+a[i-2];
        a[i]=a[i]%1000000;
    }
    while(~scanf("%d",&n))
    {
     
        printf("%d\n",a[n]);
    }
    return 0;
}

字母全排列

题目描述
编写一个程序，使用递归算法输出一个一维字符数组中所有字符的全排列，假设字符都不一样。例如{‘a’,‘b’,‘c’}的全排列为(a,b,c), (a,c,b), (b,a,c), (b,c,a), (c,a,b), (c,b,a)
输入
多组测试用例，每组输入一个正整数n(0 输出
输出从a开始，连续n个字母的全排列，且每组输出之间用空格隔开。
样例输入
1
2
样例输出
a
ab
ba

AC代码

#include 
using namespace std;
 
void test(char a[],int n)
{
     
    for(int i=0;i<n;i++)
    {
     
        printf("%c",a[i]);
    }
    printf("\n");
}
void perm(char a[],int k,int n)
{
     
     if(k==n)
    {
     
        test(a,n);
    }
    for(int i=k;i<n;i++)
    {
     
        char temp=a[k];a[k]=a[i];a[i]=temp;
        perm(a,k+1,n);
        temp=a[k];a[k]=a[i];a[i]=temp;
    }
}
int main()
{
     
    int n;
    while(~scanf("%d",&n))
    {
     
        char a[n];
        for(int i=0;i<n;i++)
        {
     
            a[i]='a'+i;
        }
        perm(a,0,n);
        printf("\n");
    }
    return 0;
}
 

如有错误，恳请指正
最后，如果这篇文章对你有帮助，欢迎一键三连

要么努力，要么放弃