递归函数

递归函数

递归函数（一）

适用于解决可以被分解为类似子问题的问题。

递归函数通常由两个主要部分组成：

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

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

案例一：计算累加

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

起始条件：f(1) = 1

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

object G04 {
  // 1.可能会导致死循环
  // 2.适合解决一类问题：
  // （1）可以把大问题，拆分成同类的小问题
  // （2）当问题足够小的时候，可以直接求解。

  // f(n)   = 1 + 2 + 3 + 4 + ... + n

  // f(100) = 1 + 2 + 3 + 4 + ... + 99 + 100
  def sum(n: Int): Int = {
    if (n == 1) {
      1
    } else {
      sum(n-1) + n
    }
  }

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

案例二： 整数的阶乘

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

起始条件：0! = 1

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

object G05 {
  // 求阶乘
  // f(n) = 1 * 2 * 3 * 4....* n
  def f(n:Int): Int = {
    if (n == 0) {
      1
    } else {
      n * f(n - 1)
    }
  }

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

递归函数（二）

a的n次方

a的n次方就是n个a相乘。

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

递归规则：f(a,n) = a * f(a, n-1)（当 n ≥ 1）。求它的第n项。

object H01 {
  /*
  * 写函数，完成功能：计算a的n次方
  *
  * f(a,n)= a * f(a, n-1)
  **/
  def f(a: Int, n: Int): Int = {
    if (n == 0) {
      1
    } else {
      a * f(a,n-1)
    }
  }

  def main(args: Array[String]): Unit = {
    val s = f(2, 3)
    println(s) // 8
  }
}

汉诺塔游戏

【讲解游戏说明】有三根柱子，标记为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 H02 {
  /*
  * 汉诺塔游戏
  *
  * */

  // A: 起点，C表示终点，B表示可以借用的柱子
  def f(n: Int, A: String, C: String, B: String): Unit = {
    if (n == 1) {
      println(s"${A} → ${C}")
    } else {
      f(n - 1, A, B, C)
      println(s"${A} → ${C}")
      f(n - 1, B, C, A)
    }
  }

  def main(args: Array[String]): Unit = {
    f(5, "A", "C", "B")
  }
}