Android-Kotlin-递归与尾递归

递归：

阶乘计算:

　　　　 /**
         * 阶乘：
         *      1的阶乘是1，因为1往下走一个楼梯 就是0了
         *      2的阶乘是 2*1
         *      3的继承是 3*2*1
         *      4的继承是 4*3*2*1
         *      5的阶乘是 5*4*2*1
         */

package cn.kotlin.kotlin_base06

import java.lang.Exception

/**
 * 递归
 */
fun main(args: Array<String>) {

    while (true) {

        println("请输入整数，用于计算阶乘...")
        var inputNumber = readLine()

        var number: Int = 0

        try {
            // inputNumber!!.toInt()  !!代表一定不会为空，所以Kotlin才放心的让我.toInt() 编译通过
            number = inputNumber!!.toInt()

        } catch (e: Exception) {
            println("你输入的不是整数...")
        }

        /**
         * 阶乘：
         *      1的阶乘是1，因为1往下走一个楼梯 就是0了
         *      2的阶乘是 2*1
         *      3的继承是 3*2*1
         *      4的继承是 4*3*2*1
         *      5的阶乘是 5*4*2*1
         */
        var result = operation(number!!)
        println("计算结果是>>>>>>>>>>>>>${result}")

    }
}

/**
 * 定义运算number的方法
 * 返回计算结果
 */
fun operation(number: Int) : Int {
    var result = when(number) {
        1 -> 1
        else -> number * operation(number - 1)
    }
    return result
}

执行结果:

尾递归：

累加计算：

/**
 * 累加计算：
 *      1的累加是1，因为1下面是0 没得 +加了
 *      2的累加是 2+1
 *      3的累加是 3+2+1
 *      4的累加是 4+3+2+1
 *      5的累加是 5+4+3+2+1
 *      .......
 */ 

累加计算【案例一】：

package cn.kotlin.kotlin_base06

/**
 * 尾递归
 */
fun main(args: Array<String>) {

    /**
     * 累加计算：
     *      1的累加是1，因为1下面是0 没得 +加了
     *      2的累加是 2+1
     *      3的累加是 3+2+1
     *      4的累加是 4+3+2+1
     *      5的累加是 5+4+3+2+1
     *      .......
     */
    var result = addOperation(4)
    println("累加计算的结果是:${result}")
}

/**
 * 定义运算number的方法
 * 返回计算结果
 */
fun addOperation(number: Int) : Int {
    var result = when(number) {
        1 -> 1
        else -> number + addOperation(number - 1)
    }
    return result
}

执行结果：

---

---

累加计算 【案例二】，对以上【案例一】进行了 更大值得累加 来复习溢出的异常：

只把需要累加的值，100000的累加：

var result = addOperation(100000)

package cn.kotlin.kotlin_base06

/**
 * 尾递归
 */
fun main(args: Array<String>) {

    /**
     * 累加计算：
     *      1的累加是1，因为1下面是0 没得 +加了
     *      2的累加是 2+1
     *      3的累加是 3+2+1
     *      4的累加是 4+3+2+1
     *      5的累加是 5+4+3+2+1
     *      .......
     */
    var result = addOperation(100000)
    println("累加计算的结果是:${result}")
}

/**
 * 定义运算number的方法
 * 返回计算结果
 */
fun addOperation(number: Int) : Int {
    var result = when(number) {
        1 -> 1
        else -> number + addOperation(number - 1)
    }
    return result
}

执行结果，溢出的异常：

---

---

以上【案例二】，引发了溢出的异常，是因为计算机运算了N多次，都计算不完 因为太多了，所以计算机直接抛出了溢出的溢出

以下【案例三】是使用Kotlin提供的 尾递归优化机制，来解决溢出的异常问题：

package cn.kotlin.kotlin_base06

/**
 * 尾递归
 */
fun main(args: Array<String>) {

    /**
     * 累加计算：
     *      1的累加是1，因为1下面是0 没得 +加了
     *      2的累加是 2+1
     *      3的累加是 3+2+1
     *      4的累加是 4+3+2+1
     *      5的累加是 5+4+3+2+1
     *      .......
     */
    var r = 0
    addOperation(100000, r)
}

/**
 * 增加了tailrec尾递归优化机制后，它认为以下返回的不是递归操作，所以需要修改
 */
/*
tailrec fun addOperation(number: Int) : Int {
    var result = when(number) {
        1 -> 1
        else -> number + addOperation(number - 1)
    }
    return result
}*/

/**
 * 增加了tailrec尾递归优化机制后，它认为以下返回的不是递归操作，所以需要修改
 */
/**
 * 定义运算number的方法
 * 返回计算结果
 */
tailrec fun addOperation(number: Int, r: Int) : Int {
    println("累加计算的结果是:${r}, 计算机在第${number}次计算....")
    if (1 == number) {
        return 1
    } else {
        return addOperation(number - 1, r + number)
    }
}

执行结果：不会出现溢出的异常了：

增加了tailrec尾递归优化机制后，它会去判断是否是递归，所以不能用when来判断，否则他认为这不是递归 还是会引发溢出溢出，最好用if return 自身的方法