（一）递归函数的定义和格式
递归是一种常用的解决问题的方法，特别适用于解决可以被分解为类似子问题的问题。递归函数通常由两个主要部分组成：起始条件（或基线条件）和递归规则（或递归关系）。
起始条件：一个递归的终止条件，确保递归不会无限进行。它处理最简单的情况并返回结果.
递归规则：在这个部分，函数会调用自身，以解决一个更小的子问题。
object base44 {
/**
* 递归函数：自己调用自己的函数
*
*/
//定义函数
def f():Unit = {
println(".....被调用了")
f()//调用函数
}
def main(args: Array[String]): Unit = {
f()
println("over")
}
}
注意：
自己调用自己可能会产生死循环
基本结构:
def recursiveFunction(parameters): ReturnType = {
// 起始条件
if (base condition) {
return base case result
} else {
// 递归规则
return recursiveFunction(smaller parameters)
}
}
(二）案例一：计算累加
计算一个整数的累加是一个经典的递归问题。假设我们要计算 n 的累加和，记作 f(n) = 1 + 2 + 3 + ... + n ，其定义为：
起始条件：f(1) = 1
递归规则：f(n)= n + f(n-1)
object base45 {
/**
* 递归函数：自己调用自己的函数
* 适合用来解决一类问题
* 1.可以被分解为类似子问题
* 2.当分解到足够小的时候，问题可以直接求解
*
*
* 任务：求 1 + 2 + 3 +... + 99 + 100 的和（5050）
*
* 分解 (1+2+3+4+...+99) + 100
*
* (1+2+3+4+...+98) + 99
*
* 任务分解到足够小：1 → 1
*
* 通项公式: (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)!
object base46 {
/*
* 适合用来解决一类问题
* 1. 可以被分解为类似子问题
* 2. 当分解到足够小的时候，问题可以直接求解
*/
// 阶乘 n! = 1 * 2 * 3 *... * n
// n = 1 → 1
// f(n) = 1*2*3*4...*(n-1)*n
// f(n-1) = 1*2*3*...*(n-1)
// f(n) = f(n-1) * n
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 base47 {
/**
* 递归函数：自己调用自己的函数
* 适合用来解决一类问题
* 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）
object base48 {
// 把输入的整数的各个位上的数值输出来！
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
}
}
结果如图：
（六）案例五：汉诺塔游戏
有三根柱子，标记为A、B、C，A柱子上有n个大小不同的盘子，盘子从下到上按照大小递增排列。现在需要将A柱子上的所有盘子移动到C柱子上，移动过程中可以借助B柱子，但是每次只能移动一个盘子，并且大盘子不能放在小盘子上面。
目标状态 移动过程中的违规状态（大盘子在小盘子上面）：
套一下递归函数的规则：
起始条件：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 base49 {
// f(n, A, B, C)
// (盘子的数量，起点，要借用的柱子，终点)
// 目标：在 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')
}
}
结果如图：
