Scala 递归函数<1>

递归函数一

• 递归是一种常用的解决问题的方法，特别适用于解决可以被分解为类似子问题的问题。

• 递归函数通常由两个主要部分组成：起始条件（或基线条件）和递归规则（或递归关系）。

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

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

• 递归：在函数内部 自己调用自己

特点：

1. 可能会导致死循环：一直调用自己
2. 问题拆解到足够小的时候 可以直接求解

/**
   * 递归：在函数内部 自己调用自己
   *
   * 特点：
   *    1.可能会导致死循环：一直调用自己
   */

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

    f()
  }

  def main(args: Array[String]): Unit = {
    f()
//    while(true){
//      println("f函数被调用了......")//
//    }

    println("main")
  }

案例一：计算累加

求 1 + 2 + 3 +...+ 99 + 100 的和 （5050)

假设我们要计算 n 的累加和，记作 f(n) = 1 + 2 + 3 + ... + n ，其定义为：

起始条件：f(1) = 1

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

/**
* 递归：在函数内部 自己调用自己
* 递归函数的应用场景
*
* 特点：
*    1.可能会导致死循环：一直调用自己
*    2.问题拆解到足够小的时候 可以直接求解
*
*举例：
*   大任务：求 1 + 2 + 3 +...+ 99 + 100 的和 （5050）
*   记 f(n) = 1 + 2 + 3 + 4 +...+ n
*   f(100) = 1 + 2 + 3 + 4 +...+ 98 + 99 + 100
*   f(99) = 1 + 2 + 3 + 4 +...+ 98 + 99
*   f(98) = 1 + 2 + 3 + 4 +...+ 98
*
*   f(100) = f(99) + 100
*   f(99) = f(98) + 99
*   ....
*   ...
*   f(1) = 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(100)
 println(rst)
}

案例二： 整数的阶乘

假设我们要计算 n 的阶乘，记作 n!=1 * 2 * 3 * 4 ... n , 其定义为：

起始条件：0! = 1

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

def f(n: Int): Int = {  

  if (n == 0) {  
    1 // 起始条件  
  } else {  
    n * f(n - 1) // 递归规则  
  }  

}

案例三： 斐波那契数列

斐波那契数列的定义是：

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

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

/**
 * 求斐波那契数列数据的第 n 项
 *
 * f(1) = 1 (足够小的时候 可以直接求解)
 * f(2) = 2
 *
 * f(n) = f(n-1) + f(n-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(5)
  println(rst)
}