学习kotlin系列之五（递归和迭代）

1、递归和尾递归优化

1）递归

递归：把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来。只需要少量的程序就可描述出解题过程所需要的多次重复计算

fun main(args: Array<String>) {
//求5的阶乘 5*4*3*2*1
//    println(fact(5))
    println(fibonacci(6))
}

/**
 * 求n的阶乘
 */
fun fact(n: Int): Int {
    if (n == 1) {
        return 1
    } else {
        return n * fact(n - 1)
    }
}

//斐波拉切数列 1 1 2 3 5 8 13 21
fun fibonacci(n: Int): Int {
    return if (n == 1 || n == 2) {
        1
    } else {
        fibonacci(n - 2) + fibonacci(n - 1)
    }
}

2）尾递归优化

尾递归：函数在调用自己之后没有执行其他任何操作的就是尾递归；
使用递归方法，递归容易报内存溢出， 解决就是使用尾递归。
步骤：
第一步：需要将递归转换为尾递归
第二步：加上tailrec
原理：还是迭代

fun main(args: Array<String>) {
//需求：求1到n的数据和 1到10
    println(sum(100000))//使用递归内存溢出
    println("${2%5}")
}

tailrec fun sum(n: Int, result: Int = 0): Int {
    if (n == 1) {
        return result + 1
    } else {
        return sum(n - 1, result + n)
    }
}

2、递归和迭代

递归和迭代的对比
常见问题：通过迭代好递归都可以解决，复杂的问题用递归更容易实现

递归和迭代有什么优缺点？
递归：逻辑比较简单 容易实现 缺点：容易占内存溢出
迭代：优点：内存开销小 缺点：抽象出数学模型

fun main(args: Array<String>) {
//需求：求1到n的数据和 1到10
//    println(sum(100000))//使用递归内存溢出
    println(sum1(100000))//使用迭代没问题
}

/**
 * 求和使用迭代的方法
 */
fun sum1(n: Int): Int {
    var result = 0
    var copyN: Int = n
    while (copyN > 0) {
        result += copyN
        copyN--
    }
    return result
}

/**
 * 使用递归方法
 */
fun sum(n: Int): Int {
    if (n == 1) {
        return 1
    } else {
        return n + sum(n - 1)
    }
}