函数递归

程序调用自身的编程技巧称为递归，递归通常是把一个大型的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策咯只需少量的程序就可描述出解题过程中所需要的多次重复计算，大大地减少了程序的代码量。递归的主要思考方式在于：把大事化小。

递归的两个必要条件

• 存在限制条件，但满足这个限制条件时，递归便不再继续

• 每次递归调用之后越来越接近这个条件

  练习

  1.

  代码如下

//接受一个整型值（无符号），把他转化成字符并打印它
//例如输入：1234，输出 1 2 3 4

#include <stdio.h>
#include <windows.h>

void print(int n)
{
    if (n > 9) //限制条件
    {
        print(n / 10); //每次逼近跳出条件
    }
    printf("%d\n", n % 10);
}
int main()
{
    int num = 1234;
    print(num);
    system("pause");
    return 0;
}

2.

代码如下

//编写函数，不允许创建临时变量，求字符串长度

#include <stdio.h>
#include <windows.h>

int mystrlen(const char *str)
{
    if (*str == '\0') //限制条件
    {
        return 0;
    }
    else
        return 1 + (mystrlen(str + 1));//指针向后移一位
}
int main()
{
    char *p = "abcd";
    int len = mystrlen(p);
    printf("%d\n", len);
    system("pause");
    return 0;
}

演示

递归与迭代

代码如下

//求n的阶乘（不考虑溢出）
int factorial(int n)
{
    if (n <= 1)
        return 1;
    else
        return n* factorial(n - 1);
}

//求第n个斐波那契数（不考虑溢出）
int fib(int n)
{
    if (n <= 2)
        return 1;
    else
        return fib(n - 1) + fib(n - 2);
}

我们发现几个问题

• 在使用factorial函数求10000的阶乘（不考虑结果的正确性），程序会崩溃。
• 在使用fib函数时如果我们要计算第50个斐波那契数时会特别耗费时间。

原因

factorial函数

在调试factorial函数时，如果参数过大，那么就会报错。这是因为系统分配给程序的栈空间是有限的，如果出现了死循环或者死递归，有可能导致一直开辟栈空间，最终产生栈空间耗尽的情况，这种现象我们通常称为栈溢出

fib函数

我们在fib函数中插入一个计数器

int count = 0;
int fib(int n)
{
if (n == 3)
count++;
if (n <= 2)
return 1;
else
return fib(n - 1) + fib(n - 2);
}

当我们输出count时，会是一个很大很大的值。

解决方法

1. 将递归改写成非递归
2. 使用static对象代替nonstatic局部对象。在递归函数设计中，可以使用static对象代替nonstatic局部对象（即栈对象），这不仅减少每次递归调用和返回时产生和释放nonstatic对象的开销，而且static对象还可以保存递归调用的中间状态，并且可为各个调用层所访问。

代码如下

//求n的阶乘（不考虑溢出）
int factorial(int n)
{
    int result = 1;
    while (n > 1)
    {
        result *= n;
        n -= 1;
    }
    return result;
}

//求第n个斐波那契数（不考虑溢出）
int fib(int n)
{
    int result;
    int pre_result;
    int next_older_result = 1;
    result = pre_result = 1;
    while (n > 2)
    {
        n -= 1;
        next_older_result = pre_result;
        pre_result = result;
        result = pre_result + next_older_result;
    }
    return result;
}

总结

1. 许多问题是以递归的形式进行解释的。这只是因为它比非递归的形式更为清晰。
2. 但是这些问题的迭代实现往往比递归实现效率更高，虽然代码的可读性稍微差些。
3. 当一个问题相当复杂，难以用迭代实现时，此时递归实现的简洁性便可以补偿它所带来的运行时开销。