C语言学习记录——구 函数和递归（2）

目录

一、函数递归

二、递归练习

1、接受一个整型值（无符号）， 按照逆序打印它的每一位。例如：输入：1234，输出：4321。

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

3、求n的阶乘

4、求第n个斐波那契数（不考虑溢出）（前两个数之和等于第三个）

---

针对add函数，再写一点。写三个文件引用。

add.h文件

#ifndef __ADD_H__

#define __ADD_H__

int Add(int x, int y);

#endif

#ifndef——if not define，如果没定义。最一开始程序时，确实没有定义，所以为真。之后定义一下，写出函数主体，#endif结束。而多次引用，第一行代码由于之前已经定义过，所以为假，所以剩下的都不能执行，这样就防止同一个文件被引用多次，造成程序负担。

add.h文件

int Add(int x, int y)
{
    return x + y;
}

test.c 文件

#include <stdio.h>
#include "add.h"

int main()
{
    int a = 10;
    int b = 20;
    int sum = Add(a, b);
    printf("%d\n", sum);
    return 0;
}

设立多个文件引用，是为了不给程序添加负担。假如一个团队做一个程序，每个人都往里面添加代码，所以如果设立多个文件，这样执行程序的文件里就不会有重复好多次的代码。

一、函数递归

程序调用自身的编程技巧称为递归(recursion)。递归做为一种算法在程序设计语高中广泛应用。一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似能规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。

递归的主要思考方式在于:把大事化小

递归的两个必要条件
存在限制条件当满足这个限制条件的时候，递归便不再继续
每次递归调用之后越来越接近这个限制条件。

int main()
{
    printf("haha\n");
    main();
    return 0;
}

这里会一直打印hehe，但是打印一段时间会出现错误，是栈溢出错误。当申请内存时，内存会分成三个区。栈区，放入局部变量，函数形参；堆区，动态开辟的内存，malloc，calloc等；静态区，全局变量，static修饰的变量。调用main函数时，在栈区申请空间，打印函数也在栈区申请空间，所以一直申请，空间满了后，出现一个错误，stack overflow——栈溢出。

二、递归练习

1、接受一个整型值（无符号）， 按照逆序打印它的每一位。例如：输入：1234，输出：4321。

void Print(int n)
{
    if (n == 0)
        return;
    printf("%d ", n % 10);
    n /= 10;
    Print(n); 
}

int main()
{
    unsigned int num = 0;
    scanf("%ld", &num);
    Print(num);
    return 0;
}

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

int my_strlen(char* str)
{
    int count = 0;
    while (*str != '\0')
    {
        count++;
        str++;
    }
    return count;
}

int main()
{
    char arr[] = "yyy";
    int len = my_strlen(arr);// arr是数组，数组传参，传过去的是第一个元素的地址
    printf("len = %d\n", len);
    return 0;
}

上面的代码里，str里是y的地址。str是一个指针变量，当查到不是\0时，数字加1，str这个指针也加1，指向y，然后再判断。运用while才能重复循环。最后检查到\0时，循环停了下来，返回count，也就是3。count是一个计数器，用来记录字符。但是现在不让创建临时变量，所以需要改一下：

把大事化小

my_strlen("yyy");

1+my_strlen("yy");

1+1+my_strlen("y");

1+1+1+my_strlen("")每次检测不是\0，那么加1，然后看之后那个字符，一直推进，知道里面只剩\0，也就是空字符串了，长度就是0了，所以1+1+1+0 = 3。

int my_strlen(char* str)
{
    if (*str != '\0')
        1 + my_strlen(str + 1);
    else
        return 0;
}

最后结果是3。就符合条件了。

3、求n的阶乘

int Fac1(int n)
{
    int i = 0;
    int ret = 1;
    for (i = 1; i <= n; i++)
    {
        ret *= i;
    }
    return ret;
}

int main()
{
    int n = 0;
    int ret = 0;
    scanf("%d", &n);
    ret = Fac1(n);
    printf("%d\n", ret);
    return 0;
}

运用递归：

int Fac2(int n)
{
    if (n <= 1)
        return 1;
    else
        return n * Fac2(n - 1);
}

4、求第n个斐波那契数（不考虑溢出）（前两个数之和等于第三个）

可以看作当n<= 2时，是1，n>2时，是fib(n-1) + fib(n-2)，假设函数fib。

int Fib(int n)
{
    if (n <= 2)
        return 1;
    else
        return Fib(n - 1) + Fib(n - 2);
}

int main()
{
    int n = 0;
    int ret = 0;
    scanf("%d", &n);
    ret = Fib(n);
    printf("ret = %d\n", ret);
    return 0;
}

但是效率低这个程序。假如给47，那么需要算46和45的数值，然后46需要45和44的数值，以此类推，很麻烦。所以用递归来算不太合适。测试一下第三个斐波那契数被算了多少次，在函数外定义一个count，传进去来计数：

    if (n == 3)
        count++;

if( n <= 2).....

在ret后面

printf("count = %d\n", count）

 如果输入40，count会是近乎于4千万次。

递归数列就会很麻烦，这里只是在说递归不是所有的问题都可以简化运算，有些不适合。更好的办法就是用循环。

int Fib(int n)
{
    int a = 1;
    int b = 1;
    int c = 0;
    while (n > 2)
    {
        c = a + b;
        a = b;
        b = c;
        n--;
    }
    return b;
}

计算速度会很快，虽然如果数值过大，造成溢出，数值错误，但是速度够快。

递归的两个必要条件
存在限制条件当满足这个限制条件的时候，递归便不再继续
每次递归调用之后越来越接近这个限制条件。

满足这两个条件后，程序也不一定对。

void test(int n)
{
    if (n < 10000)
        test(n + 1);
}

int main()
{
    test(1);
    return 0;
}

运行起来后，会出现栈溢出。所以递归要注意栈溢出。

结束。