递归(Recursion)的两种优化方法

递归(Recursion)的两种优化方法


最近学习了一些递归的优化方法,于是想写一篇文章记录一下,方便以后查看,并想分享一下。
虽然平日的上课中老师都是建议我们不要使用递归,但是在函数式编程(functional programming)中递归是很常用的,而且掌握递归的思想有时能让我们找到最优解。

1. 最经典的斐波那契数列

int Fibonacci(int n) {
    if (n == 1 || n == 2) {
        return 1;
    }
    else
    {
        return Fibonacci(n - 2) + Fibonacci(n - 1);
    }
}

这个算法一般计算到40左右就不行了,因为运行栈已经被函数的递归调用占满了

2. 尾递归(Tail Recursive)

传说中的尾递归。具体我不细说了,就是上一个版本的优化,每次调用函数时不生成新的运行栈,利用上一次的结果
注意:不是所有语言都有尾递归优化的(Java就没有)
也不是所有算法都能写成尾递归的形式的

int fiboTail(int n, int acc, int cal) 
//acc充当收集器的左右,收集上一次运行栈的返回值,因为之后栈空间会被回收
//cal是每一次递归的计算
{
    if (n == 1) return acc;
    if (n == 2) return cal;
    return fiboTail(n - 1, cal, acc+cal);
}

可以看到尾递归的函数比原始的版本多了2个参数,一个起到收集器(accumulator)的作用,记录每上一次栈的返回值,因为原来栈的空间会被下一层递归覆盖。
还有一个参数就是每次递归的操作了,因为是斐波那契,所以这里是相加。

尾递归的调用方法也与原来的不一样,因为斐波那契的初始值 ( 1. 1 . 2 . 3 ……)
所以以下的调用,acc 要用初始值 1,cal 也要用第二位的值这里也是1
调用的方法就是 fiboTail(n, 1,1)
尾递归的方法计算基本上是秒出的,可是比起下面一种方法还是要慢,就是在32位机器上要注意 int范围 第47位已经超过int的表示范围了

3. 利用缓存

典型的空间换时间

enum { gnFib = 99 };  
int gFib[gnFib];      // 生成一个数组记录已经生成的斐波那契数

int fib(int n)    
{
    if (n < 0 || n >= gnFib) return 0;
    int &fn = gFib[n];   
    if (!fn) {            //如果当前数不在数组中才计算
        if (n == 0 || n == 1) fn = 1;
        else fn = fib(n - 1) + fib(n - 2);
    }
    return fn;
}

核心思想就是利用之前信息,每次递归不用再重新计算了

### 回答1: 尾递归优化的实现方法有以下几种:1、尾递归替换: 即将尾递归调用替换成循环;2、尾递归展开: 即将尾递归函数展开成一系列的嵌套调用;3、尾递归优化: 将尾递归优化成线性递归;4、尾递归消除: 将尾递归消除成非递归形式。下面是一个示例代码:def tail_recursion(n): if n == 0: return 0 return tail_recursion(n - 1)# 尾递归替换 def tail_recursion_1(n): while n > 0: n -= 1 return 0# 尾递归展开 def tail_recursion_2(n): if n == 0: return 0 else: return tail_recursion_2(n - 1)# 尾递归优化 def tail_recursion_3(n, result): if n == 0: return result else: return tail_recursion_3(n - 1, n + result)# 尾递归消除 def tail_recursion_4(n): result = 0 while n > 0: result = n + result n -= 1 return result ### 回答2: Python尾递归优化是通过对递归函数进行重写或者使用特定的装饰器来实现的。尾递归是指递归函数中最后一个操作是递归调用,并且递归调用的返回值直接被返回,减少了堆栈的使用。 以下是几种实现尾递归优化方法: 1. 重写递归函数:将递归函数转换为迭代的形式。使用循环代替递归调用,将递归函数的参数作为循环变量,更新参数的值,并在循环结束后返回结果。 ```python def factorial(n): result = 1 while n > 0: result *= n n -= 1 return result ``` 2. 使用尾递归优化的装饰器:使用装饰器对递归函数进行尾递归优化。装饰器会判断递归函数最后一个操作是否为递归调用,并将递归调用的返回值直接返回。 ```python def tail_recursion_optimization(func): def wrapper(*args, **kwargs): while True: result = func(*args, **kwargs) if not isinstance(result, tuple) or result[0] != 'recursion': return result args = result[1:] return wrapper @tail_recursion_optimization def factorial(n, acc=1): if n == 0: return acc return 'recursion', n - 1, acc * n ``` 以上是两种常见的实现尾递归优化方法,根据实际需要选择合适的方式来优化递归函数,减小堆栈的使用。 ### 回答3: 尾递归优化是指在递归函数中,将最后一步的计算结果作为参数传递给下一次递归调用,从而避免了递归过程中的中间结果堆栈的保存,减少了内存消耗和栈空间的占用。 实现尾递归优化方法有以下几种: 1. 循环迭代法:通过循环取代递归,将递归转化为循环的形式,将最后一步的计算结果作为循环变量,从而实现尾递归优化。示例代码如下: ```python def factorial(n): result = 1 while n > 1: result *= n n -= 1 return result ``` 2. 尾递归修饰器:通过定义一个修饰器,将尾递归函数装饰为尾递归优化的版本。示例代码如下: ```python def tail_recursion(func): def wrapper(*args, **kwargs): while True: new_args, new_kwargs = func(*args, **kwargs) if new_args is None: return new_kwargs else: args, kwargs = new_args, new_kwargs return wrapper @tail_recursion def factorial(n, acc=1): if n == 0: return None, acc else: return (n-1, acc*n), None ``` 3. 使用内部函数法:在递归函数内部定义一个辅助函数来实现尾递归优化。示例代码如下: ```python def factorial(n): def tail_factorial(n, acc=1): if n == 0: return acc else: return tail_factorial(n-1, acc*n) return tail_factorial(n) ``` 注意:以上是针对尾递归优化的一些常用方法,不同的语言和编译器可能会有不同的实现方式。
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值