（十二)递归函数⑴(一)递归函数的定义和格式递归是一种常用的解决问题的方法，特别适用于解决可以被分解为类似子问题的问题

(一)递归函数的定义和格式

递归是一种常用的解决问题的方法，特别适用于解决可以被分解为类似子问题的问题。递归函数通常由两个主要部分组成：起始条件（或基线条件）和递归规则（或递归关系）。

递归函数：自己调用自己的函数，适合用来解决一类问题

1. 可以被分解为类似子问题
1. 当分解到足够小时，问题可以直接求解

起始条件：一个递归的终止条件，确保递归不会无限进行。它处理最简单的情况并返回结果.

递归规则：在这个部分，函数会调用自身，以解决一个更小的子问题。

代码如下

object Base51 {
  /**
   * 递归函数：自己调用自己的函数
   */
  // 定义函数
  def f(): Unit = {
    println("……被调用了")

    
    f() // 调用函数
  }

  def main(args: Array[String]): Unit = {
    f()

    println("over")
  }
}

注意：递归函数，自己调用自己，可能会产生循环。

（二）案例一：计算累加

计算一个整数的累加是一个经典的递归问题。假设我们要计算 n 的累加和，记作 f(n) = 1 + 2 + 3 + ... + n ，其定义为：

起始条件：f(1) = 1

递归规则：f(n)= n + f(n-1)

任务: 求 1 + 2 + 3 + ... + 99 + 100 的和 (5050)


object Base52 {
  /*
任务: 求 1 + 2 + 3 + ... + 99 + 100 的和 (5050)
分解 (1+2+3+4+....+99) + 100
(1+2+3+4+....+98) + 99
...
任务分解到足够小:
1 + 1
通项公式: f(n) = 1 + 2 + 3 + ... + n
f(1) = 1
f(n) = f(n-1) + n
*/
  // 1 + 2 + 3 + …… + n
  def f(n:Int):Int = {
    if(n == 1)
      1
    else
      f(n-1) + n
  }

  def main(args: Array[String]): Unit = {
    val rst = f(100)
    println(rst)
  }

}

（三）案例二：整数的阶乘

计算一个整数的阶乘是一个经典的递归问题。假设我们要计算 n 的阶乘，记作 n!=123*4...*n，其定义为：

起始条件：0! = 1

递归规则：n! = n * (n-1)!

任务:求阶乘 n!=1234...n


object Base53 {
  def f(n:Int):Int = {
    if(n == 1) {
      1
    } else {
      f(n-1) * n
    }
  }

  def main(args: Array[String]): Unit = {
    val rst = f(4) // 1×2×3×4 = 24
    println(rst)
  }

}

（四）案例三：斐波那契数列

斐波那契数列的定义是：

起始条件：f(0) = 0 , f(1) = 1

递归规则：f(n) = f(n-1) + f(n-2)（当 n ≥ 2）。

任务：求它的第n项。

代码如下：


object Base54 {
  /**
   * 递归函数，自己调用自己的函数
   * 适合用来解决一类问题
   * 1、可以被分解为类似子问题
   * 2、当分解到足够小时，问题可以直接求解
   */

  // 斐波那契数列
  def f(n:Int):Int = {
    if(n == 1) {
      1
    } else if(n == 2) {
      2
    } else {
      f(n-1) + f(n-2)
    }
  }

  def main(args: Array[String]): Unit = {
    val rst = f(10) // 89
    println(rst)
  }

}

（五）案例四：打印数字的各个位数

起始条件：f(n) = 输出个位 , n<9

递归规则：f(n) = f(n/10）+ 输出个位（当 n ≥ 10）

任务：对于整数1234，依次输出1,2,3,4这4个数字。

代码如下：


object Base54 {
  // 把输入的整数的各个位数上的数值输出来！
  def f(n:Int):Unit = {
    if(n<9){
      println(n)
    } else {
      f(n/10)
      println(n%10)
    }
  }

  def main(args: Array[String]): Unit = {
    f(12345) // 1 2 3 4 5
  }


}

（六）案例五：汉诺塔游戏

起始条件：f(1) = 从A直接移动到C

递归规则：f(n) = 把n-1从A移动到B, 把1从A移动到C, 把n-1从B 移动到C

f(n,a,b,c): 把n个盘子从a移动到c,借助b。


object Base56 {
  // f(A, B, C)
  // f(盘子的数量，起点，要借用的柱子，终点)
  // 目标：在A上有n个盘子，我们需要借助B，把他们都移动到 C
  /*
    如果：n == 1。直接从 A 移动到 C
    否则：
    * 1、把n-1个盘子从A 移动到 B
    * 2、把一个盘子从A移动到C
    * 3、把n-1个盘子从 B 移动到 C
   */
  def f(n:Int, A:Char, B:Char, C:Char): Unit = {
    if (n == 1) {
      println(s"${A} ---> ${C}")
    } else {
      f(n - 1, A, C, B)
      println(s"${A} ---> ${C}")
      f(n - 1, B, A, C)
    }
  }
  def main(args: Array[String]): Unit = {
    f(4, 'A', 'B', 'C')
  }

}

（十二)递归函数⑴