递归函数

一.递归函数的定义和格式

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

• 起始条件：一个递归的终止条件，确保递归不会无限进行。它处理最简单的情况并返回结果.
• 递归规则：在这个部分，函数会调用自身，以解决一个更小的子问题。

1.1适合用来解决一类问题

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

//基本结构
def recursiveFunction(parameters): ReturnType = {  

  // 起始条件  

  if (base condition) {  

    return base case result  

  } else {  

    // 递归规则  

    return recursiveFunction(smaller parameters)  

  }  

}

object Base48 {
  /**
   * 递归函数：自己调用自己的函数(可能会产生死循环)
   */

  //定义函数
  def f():Unit = {
  println("f......被调用了")

  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)

object Base49 {
  /**
   * 可以使用循环来解决问题
   * 在计算过程中使用临时变量存储计算结果
   * 任务：求 1 + 2 + 3 + ...... + 99 + 100 的和（结果 5050）
   * 方法一：(1+2+3+4+...+99) + 100
   * 方法二：1 + (2+3+4+...+100)
   * 方法三：(1+100) + 99
   * 循环实现思路：
   * 通项公式：(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 Base50 {
  //阶乘 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(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 Base51 {
  /**
   递归函数：自己调用自己的函数
   适合用来解决一类问题
   可以被分解为类似子问题
   当分解到足够小的时候，问题可以直接求解
   */
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)
    println(rst)
  }
}

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

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

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

object Base52 {
  //把输入的整数的各个位数上的数值输出来！
  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)
  }
}

object Base52 {
  //把输入的整数的各个位数上的数值输出来！
  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)
  }
}

六.案例五：汉诺塔游戏

• www.4399.com/flash/24041…
• 【讲解游戏说明】有三根柱子，标记为A、B、C，A柱子上有n个大小不同的盘子，盘子从下到上按照大小递增排列。现在需要将A柱子上的所有盘子移动到C柱子上，移动过程中可以借助B柱子，但是每次只能移动一个盘子，并且大盘子不能放在小盘子上面。

object Base54 {
  // f(n, 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')
  }
}