Scala函数的递归函数

//递归函数
//递归函数定义:自己调用自己的函数就叫递归函数,可能导致死循环，需要明确写出返回值类型
//应用场景：可以用于解决可以被分解为子问题的问题。大事化小！

object sc {
  //1.函数可以自己调用自己
  //2.自己调用自己，可能导致死循环

  def fn(): Unit = {
    println("fn")
    //在函数内部自己调用自己
     //fn()
  }
  
  //记：f(n)=1+2+3+....+(n-1)+n
  //1，基本情况（直接能求的）：f(1)=1
  //2,递归情况（大事化小，自己调自己）
  def main(args: Array[String]): Unit = {
    //fn()
    //问题：求1+2+3..n的和
    
    println(getSum(4))
  }
  def getSum(n:Int): Int ={
    if(n==1){
      1
    }else{
      getSum(n-1)+n
    }
  }

//1.求两个数的最大公约数
  def main(args: Array[String]): Unit = {
    val a= sum1(4,5)
    println(s"a=$a")
    val a2=sum2(4,5)
    println(s"a2=$a2")
    println(s"gcd=${gcd(0,4)}")
  }
  def sum1(x: Int, y: Int): Int = {
    return x + y
  }
  def sum2(x: Int, y: Int): Int = return x + y
  def gcd(x: Int, y: Int): Int = {
    if (x == 0)  y
    else gcd(y % x, x)
  }

//2.求斐波那契数列的第n项
object sh {
  def fib(n:Int): Int ={
    if(n==0){
      0
    }else if(n==1){
      1
    }else{
      fib(n-1)+fib(n-2)
    }
  }
  def main(args: Array[String]): Unit = {
    println(fib(10))
  }

//3.求汉诺塔游戏的步骤
//记：f(n,"A","B","C") 表示把n个盘子从 A柱子上移动到　C柱子上，借用B柱子的过程
//f(要移动的盘子的个数，起点，辅助柱子，终点)
object hlt {
  def han(n:Int,A:String,B:String,C:String): Unit ={
    if(n==1){
      println(s"$A ---> $C")
    }else{
      //把前n-1个盘子，从A->B
      han(n-1,A,C,B)
      //把第n个盘子，从A->C
      println(s"$A ---> $C")
      //3.把第一步中前n-1个盘子：从B->C
      han(n-1,B,A,C)
    }
  }
  def main(args: Array[String]): Unit = {
  han(3,"A","B","C")
  }