递归：
阶乘计算:
/** * 阶乘： * 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 自身的方法
