递归 的 理解 与使用

                                     

1  前言

2  引入递归

3  使用 递归

1. 前言  递归 是函数的重要章节 让我们 来学习 和使用递归，递归 不 是 一下就能学会的 要多看 多练,让我们 愉快的开始本文的学习

1. 引入递归

        递归 递归 其实就是在运行的过程 调用自己

           递归 有 2 大限制条件

        1. 存在限制条件，当满足这个限制条件的时候，递归便不再继续。

               2. 每次递归调用之后越来越接近这个限制条件。

1.    使用 递归 

1.  练习 一

使用递归 将 1234 打印出来

   一般 我们的 思路     pinrt(n) --- n =1234

print(1234)

          函数内部                1234 / 10 == 123 ---4 拿出 4     

                                       1234 % 10 ==  4    打印 4  

print(123)

       函数内部                  123 / 10 ==  12 ---- 3 拿出 3 

                                       123 % 10 == 3

print(12)

        函数内部                   12 / 10 == 1 -------2 拿出 2

                                        12 % 10 == 2  ----- 打印 2

print(1)                    

        函数内部    

此时我们可以直接将   1 打印出来 因为 一个个位数 除于 10 为 0

因此 我们 可以设置 一个 限制 条件  当 传经来 的值（n） 在 每次 递归时 当

一步一步 的 减小一个位数 直到 个位数 时 直接打印出来 然后一步一步的 返回上次递归的函数

n < 9 就为本题 的 限制条件 

如果 递归 未有 限制条件 就会陷入 无终止地自身调用 (就像迷宫 只有路口，没有出口 人就会被困死在迷宫当中)

#include<stdio.h>

void print(int n)

{

       if (n > 9)

       {

              print(n / 10);

       }

       printf("%d ", n % 10);

}

int main()

{

       int n = 0;

       scanf("%d", &n);

       print(n);

       return 0;

}

附图 ：

注： 递归可以画图了解，图像 可以给人 更加直观 的体验 ，可以让我们更好的 了解递归 中 递 和 归的过程

1. 练习 二

用递归的方法 模拟 strlen 函数

我们 知道 strlen 函数 是 用来 计算 字符串的长度 

在字符串 中 寻找 ' \0 ' 才会停止寻找

例    "abcdef"

#include<stdio.h>
//abcdef 先拿出 a
//1 +bcdef
//1 + 1 + cdef
//…… 1 + 1 + 1……+0
int my_strlen(char* arr)
{
       if (*arr != '\0')
       {
              arr++;
              return 1+ my_strlen(arr);
       }
       else
       return 0;
}
int main()
{
       char arr[] = "abcdef";
       int ret = my_strlen(arr);
       printf("%d ", ret);
       return 0;
}

另外 strlen 有 多种 模拟实现

可以 观看 此文 内 赋有 strlen 递归 图

*《3种方式模拟strlen函数_mu_tong_的博客-CSDN博客》

递归 的 核心 思路 为  大事化小   可以 减少 代码量

但是 并不是 使用了递归 就会简化代码，有些时候 还会拖累 程序的运行时间

如 斐波那契数

1. 递归 完成 斐波那契数

#include<stdio.h>
int count = 0; // 可以 定义一个全局变量
       // 计入 n = 3 时 计算了多少次
int fib(int n)
{
       
       if (n == 3)
       {
              count++;
       }
       if (n >= 3)
       {
              return fib(n - 1) + fib(n - 2);
       }
       else
       {
              return 1;
       }
}
int main()
{
       int n = 0;
              printf("输入要求的斐波那契数\n");
              scanf("%d", &n);
              int ret = fib(n);
              printf("%d \n", count);
              printf("%d", ret);
       return 0;
}

1.  循环完成 斐波那契数

#include<stdio.h>
int fib(int n)
{
       int a = 1;
       int b = 1;
       int c = 1;// 如果将c 赋予 0 , n 为 1 和 2 是 返回值就是 0了
       while (n >= 3)
       {
              c = a + b;
              a = b;
              b = c;
              n--;
       }
       return c;
}
int main()
{
       int n = 0;
       printf("输入要求的斐波那契数\n");
       scanf("%d", &n);
       int ret = fib(n);
       printf("%d", ret);
       return 0;
}

两个方法都能 计算出斐波那契数 但是 递归 计算 

的数字越大 所需的时间 就越多 因为 会重复 的计算 已经计算的数字

可以看出 求第 40 个数 时就 花费了将近半分钟 而 n == 3 更是重复了 3千多万次 

而方法二 只需要几秒钟 

所以 递归 虽好 也要 合适才用哦