Thinking in scala (4)----阶乘与尾递归

code1:

object factorial{
  def main(args:Array[String])={
    println(factorial(args(0).toInt))
  }

  def factorial(x:Int):Int =
    if (x==0) 1 else x * factorial(x-1)
}

这个实现的执行过程如下,比如我们计算4的阶乘factorial(4)

factorial(4)

--> if (4==0) 1 else 4 * factorial(4-1)

-->4*factorial(3)

-->4*(3*factorial(2))

-->4*(3*(2*factorial(1)))

-->4*(3*(2*(1*factorial(0))))

-->4*(3*(2*(1*1)))

-->24

计算机在执行上述计算的过程中,需要用到“栈”,并且我们不难看到为了计算factorial(4),栈不断增大。

为了避免像这样的计算可能导致“栈溢出”,可以采用一个小技巧,就是将上述的递归转化为“尾”递归。

关于尾递归,可以参考:http://en.wikipedia.org/wiki/Tail_call

code2:

object factorial{
  def main(args:Array[String])={
    println(factorial(args(0).toInt,1))
  }

  def factorial(x:Int,result:Int):Int =
    if (x==0) result else factorial(x-1,x*result)
}

思路也很简单,不再赘述。

时间: 2024-10-03 23:56:56

Thinking in scala (4)----阶乘与尾递归的相关文章

【Scala】头等函数与函数即对象

头等函数 Scala的函数是头等函数(first-class function).你不仅可以定义和调用函数,还可以把它们写成匿名的字面量(literal),并把它们作为值传递. 函数字面量被编译进类,并在运行期实例化为函数值(function value).什么意思呢?函数的本质是类的实例.函数是一些特质的集合,任何函数值都是某个扩展了scala包的若干FunctionN特质之一的类的实例,如Function0是没有参数的函数,Function1是有一个参数的函数等等.每个FunctionN特质

尾递归=递归+迭代?

0 引言 平时见惯了递归和迭代,递归直观,但太占内存和时间,迭代运算快,但是不如递归代码简洁明了.那么可不可以把这两种算法的优点糅合在一起?答案是肯定的,尾递归就提供了这样一种机制. 1 尾递归是什么 简单地说,尾递归就是披着“递归”的外衣,却拥有一颗“迭代”的心.外观上看起来像递归,但内部进行了迭代的运算.下面举例说明. 2 阶乘示例 2.1 先看阶乘的迭代算法: 2.2 再看阶乘的递归算法: 2.3 最后看阶乘的尾递归算法: 3 斐波那契数列示例 3.1 先看斐波那契数列的迭代算法: 3.2

几种方法的尾递归实现

http://freejvm.iteye.com/blog/976878 需要找时间验证一下,另外还需要学习多个参数的尾递归如何来实现的技巧 斐波那契数列第n个数的求值, public static long fibo4(int n) { if (n < 2) { return n - 1; } else { return fibo4Helper(n, 0, 1, 3); //保持与非尾递归接口不变,是借助帮助方法实现尾递归的 } } private static long fibo4Helpe

Scala总结

===概述 scala是一门以java虚拟机(JVM)为目标运行环境并将面向对象和函数式编程的最佳特性结合在一起的静态类型编程语言. scala是纯粹的面向对象的语言.java虽然是面向对象的语言,但是它不是纯粹的,因为java的基本数据类型不是类,并且在java中还有静态成员变量和静态方法.相反,scala是纯粹面向对象的,每个值都是对象,每个操作都是方法调用. scala也是一个成熟的函数式语言.函数式编程有两个指导思想:①函数是头等值,也就是说函数也是值,并且和其他类型(如整数.字符串等)

Python3-递归函数

什么是递归? 递归,就是函数在运行的过程中调用自己. 代码示例 def recursion(n): print(n) recursion(n+1) recursion(1) 出现的效果就是,这个函数在不断的调用自己,每次调用就n+1,相当于循环了. 可是为何执行了900多次就出错了呢?还说超过了最大递归深度限制,为什么要限制呢? 通俗来讲,是因为每个函数在调用自己的时候 还没有退出,占内存,多了肯定会导致内存崩溃. 本质上讲呢,在计算机中,函数调用是通过栈(stack)这种数据结构实现的,每当进

ES6学习(二):函数的扩展

chapter07 函数的扩展 7.1 函数默认值 7.1.1 参数默认值简介 传统做法的弊端(||):如果传入的参数相等于(==)false的话,仍会被设为默认值,需要多加入一个if判断,比较麻烦. 参数变量是默认声明的,不可在函数体内部重复声明. 参数的默认值会在每次调用的时候重新计算 7.1.2 和解构赋值默认值结合使用 用两个例子来说明 Example1 function foo({x, y=5}) { console.log(x, y); } foo({}) // undefined,

递归经典问题

阶乘 1 # 阶乘 2 3 def jiecheng(n): 4 if n <= 1: 5 return 1 6 return jiecheng(n-1) * n 7 8 print(jiecheng(5)) 9 10 11 # 阶乘_尾递归 12 def jiecheng(n, val): 13 if n == 1: 14 return val 15 return jiecheng(n-1, val*n) 16 17 res = jiecheng(5, 1) 18 print(res) 斐波那

Scala Tail Recursion (尾递归)

Scala对尾递归进行了优化,甚至提供了专门的标注告诉编译器需要进行尾递归优化.不过这种优化仅限于严格的尾递归,间接递归等情况,不会被优化. 尾递归的概念 递归,大家都不陌生,一个函数直接或间接的调用它自己,就是递归了.我们来看一个简单的,计算阶乘的例子. def factorial(n: Int): Int = { if( n <= 1 ) 1 else n * factorial(n-1) } 以上factorial方法,在n>1时,需要调用它自身,这是一个典型的递归调用.如果n=5,那么

【Scala】尾递归优化

以递归方式思考 递归通过灵巧的函数定义,告诉计算机做什么.在函数式编程中,随处可见递归思想的运用.下面给出几个递归函数的例子: object RecursiveExample extends App{ // 数列求和例子 def sum(xs: List[Int]): Int = if (xs.isEmpty) 1 else xs.head + sum(xs.tail) // 求最大值例子 def max(xs: List[Int]): Int = if (xs.isEmpty) throw n