递归函数

递归函数的定义和格式

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

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

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

def recursiveFunction(parameters): ReturnType = {  

  // 起始条件  

  if (base condition) {  

    return base case result  

  } else {  

    // 递归规则  

    return recursiveFunction(smaller parameters)  

  }  

}

自己调用自己会陷入死循环

object Sc39 {
  def f():Unit = {
    println("f.....被调用了")
  }
def main(args: Array[String]): Unit = {
  f()
  println("over")
  }
}

计算累加

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

object Sc40 {
  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 Sc41 {
  def f(n:Int):Int = {
    if(n == 1)
      1
    else
      f(n-1) * n
  }
def main(args: Array[String]): Unit = {
  val rst = f(4)
  println(rst)
  }
}

斐波那契数列

斐波那契数列的定义是：

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

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

object Sc42 {
  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)
  }
}

打印数字的各个位数

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

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

object Sc43 {
  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)
  }
}

汉诺塔

起始条件：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 Sc44 {
  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')
  }
}