可能对递归理解的还不够！还差得远！

上周小结的时候就提到了，在「算法汇总」里算法性能分析这块还没补全，后序会补上，所以这就来了，要分析递归的性能咱就分析个清清楚楚!

之前在通过一道面试题目，讲一讲递归算法的时间复杂度!中详细讲解了递归算法的时间复杂度，但没有讲空间复杂度。

本篇讲通过求斐波那契数列和二分法再来深入分析一波递归算法的时间和空间复杂度，细心看完，会刷新对递归的认知!

递归求斐波那契数列的性能分析

先来看一下求斐波那契数的递归写法。

 
 
 
 
    
  
  
  
  
  1. int fibonacci(int i) { 
    2.   
  
  
  
  2.        if(i <= 0) return 0; 
    3.   
  
  
  
  3.        if(i == 1) return 1; 
    4.   
  
  
  
  4.        return fibonacci(i-1) + fibonacci(i-2); 
    5.   
  
  
  
  5. } 
    6.

对于递归算法来说，代码一般都比较简短，从算法逻辑上看，所用的存储空间也非常少，但运行时需要内存可不见得会少。

时间复杂度分析

来看看这个求斐波那契的递归算法的时间复杂度是多少呢?

在讲解递归时间复杂度的时候，我们提到了递归算法的时间复杂度本质上是要看: 递归的次数 * 每次递归的时间复杂度。

可以看出上面的代码每次递归都是O(1)的操作。再来看递归了多少次，这里将i为5作为输入的递归过程 抽象成一颗递归树，如图：

从图中，可以看出f(5)是由f(4)和f(3)相加而来，那么f(4)是由f(3)和f(2)相加而来 以此类推。

在这颗二叉树中每一个节点都是一次递归，那么这棵树有多少个节点呢?

我们之前也有说到，一棵深度(按根节点深度为1)为k的二叉树最多可以有 2^k - 1 个节点。

所以该递归算法的时间复杂度为 O(2^n) ，这个复杂度是非常大的，随着n的增大，耗时是指数上升的。

来做一个实验，大家可以有一个直观的感受。

以下为C++代码，来测一下，让我们输入n的时候，这段递归求斐波那契代码的耗时。

 
 
 
 
    
  
  
  
  
  1. #include  
    2.   
  
  
  
  2. #include  
    3.   
  
  
  
  3. #include  
    4.   
  
  
  
  4. using namespace std; 
    5.   
  
  
  
  5. using namespace chrono; 
    6.   
  
  
  
  6. int fibonacci(int i) { 
    7.   
  
  
  
  7.        if(i <= 0) return 0; 
    8.   
  
  
  
  8.        if(i == 1) return 1; 
    9.   
  
  
  
  9.        return fibonacci(i - 1) + fibonacci(i - 2); 
    10.   
  
  
  
  10. } 
    11.   
  
  
  
  11. void time_consumption() { 
    12.   
  
  
  
  12.     int n; 
    13.   
  
  
  
  13.     while (cin >> n) { 
    14.   
  
  
  
  14.         milliseconds start_time = duration_cast( 
    15.   
  
  
  
  15.             system_clock::now().time_since_epoch() 
    16.   
  
  
  
  16.         ); 
    17.   
  
  
  
  17.  
    18.   
  
  
  
  18.         fibonacci(n); 
    19.   
  
  
  
  19.  
    20.   
  
  
  
  20.         milliseconds end_time = duration_cast( 
    21.   
  
  
  
  21.             system_clock::now().time_since_epoch() 
    22.   
  
  
  
  22.         ); 
    23.   
  
  
  
  23.         cout << milliseconds(end_time).count() - milliseconds(start_time).count() 
    24.   
  
  
  
  24.             <<" ms"<< endl; 
    25.   
  
  
  
  25.     } 
    26.   
  
  
  
  26. } 
    27.   
  
  
  
  27. int main() 
    28.   
  
  
  
  28. { 
    29.   
  
  
  
  29.     time_consumption(); 
    30.   
  
  
  
  30.     return 0; 
    31.   
  
  
  
  31. } 
    32.

根据以上代码，给出几组实验数据：

测试电脑以2015版MacPro为例，CPU配置：2.7 GHz Dual-Core Intel Core i5

测试数据如下：

  • n = 40，耗时：837 ms
  • n = 50，耗时：110306 ms

可以看出，O(2^n)这种指数级别的复杂度是非常大的。

所以这种求斐波那契数的算法看似简洁，其实时间复杂度非常高，一般不推荐这样来实现斐波那契。

其实罪魁祸首就是这里的两次递归，导致了时间复杂度以指数上升。

 
 
 
 
    
  
  
  
  
  1. return fibonacci(i-1) + fibonacci(i-2); 
    2.

可不可以优化一下这个递归算法呢。主要是减少递归的调用次数。

来看一下如下代码：

 
 
 
 
    
  
  
  
  
  1. // 版本二 
    2.   
  
  
  
  2. int fibonacci(int first, int second, int n) { 
    3.   
  
  
  
  3.     if (n <= 0) { 
    4.   
  
  
  
  4.         return 0; 
    5.   
  
  
  
  5.     } 
    6.   
  
  
  
  6.     if (n < 3) { 
    7.   
  
  
  
  7.         return 1; 
    8.   
  
  
  
  8.     } 
    9.   
  
  
  
  9.     else if (n == 3) { 
    10.   
  
  
  
  10.         return first + second; 
    11.   
  
  
  
  11.     } 
    12.   
  
  
  
  12.     else { 
    13.   
  
  
  
  13.         return fibonacci(second, first + second, n - 1); 
    14.   
  
  
  
  14.     } 
    15.   
  
  
  
  15. } 
    16.

这里相当于用first和second来记录当前相加的两个数值，此时就不用两次递归了。

因为每次递归的时候n减1，即只是递归了n次，所以时间复杂度是 O(n)。

同理递归的深度依然是n，每次递归所需的空间也是常数，所以空间复杂度依然是O(n)。

代码(版本二)的复杂度如下：

  • 时间复杂度：O(n)
  • 空间复杂度：O(n)

此时再来测一下耗时情况验证一下：

 
 
 
 
    
  
  
  
  
  1. #include  
    2.   
  
  
  
  2. #include  
    3.   
  
  
  
  3. #include  
    4.   
  
  
  
  4. using namespace std; 
    5.   
  
  
  
  5. using namespace chrono; 
    6.   
  
  
  
  6. int fibonacci_3(int first, int second, int n) { 
    7.   
  
  
  
  7.     if (n <= 0) { 
    8.   
  
  
  
  8.         return 0; 
    9.   
  
  
  
  9.     } 
    10.   
  
  
  
  10.     if (n < 3) { 
    11.   
  
  
  
  11.         return 1; 
    12.   
  
  
  
  12.     } 
    13.   
  
  
  
  13.     else if (n == 3) { 
    14.   
  
  
  
  14.         return first + second; 
    15.   
  
  
  
  15.     } 
    16.   
  
  
  
  16.     else { 
    17.   
  
  
  
  17.         return fibonacci_3(second, first + second, n - 1); 
    18.   
  
  
  
  18.     } 
    19.   
  
  
  
  19. } 
    20.   
  
  
  
  20.  
    21.   
  
  
  
  21. void time_consumption() { 
    22.   
  
  
  
  22.     int n; 
    23.   
  
  
  
  23.     while (cin >> n) { 
    24.   
  
  
  
  24.         milliseconds start_time = duration_cast( 
    25.   
  
  
  
  25.             system_clock::now().time_since_epoch() 
    26.   
  
  
  
  26.         ); 
    27.   
  
  
  
  27.  
    28.   
  
  
  
  28.         fibonacci_3(0, 1, n); 
    29.   
  
  
  
  29.  
    30.   
  
  
  
  30.         milliseconds end_time = duration_cast( 
    31.   
  
  
  
  31.             system_clock::now().time_since_epoch() 
    32.   
  
  
  
  32.         ); 
    33.   
  
  
  
  33.         cout << milliseconds(end_time).count() - milliseconds(start_time).count() 
    34.   
  
  
  
  34.             <<" ms"<< endl; 
    35.   
  
  
  
  35.     } 
    36.   
  
  
  
  36. } 
    37.   
  
  
  
  37. int main() 
    38.   
  
  
  
  38. { 
    39.   
  
  
  
  39.     time_consumption(); 
    40.   
  
  
  
  40.     return 0; 
    41.   
  
  
  
  41. } 
    42.

测试数据如下：

  • n = 40，耗时：0 ms
  • n = 50，耗时：0 ms

大家此时应该可以看出差距了!!

空间复杂度分析

说完了这段递归代码的时间复杂度，再看看如何求其空间复杂度呢，这里给大家提供一个公式：递归算法的空间复杂度 = 每次递归的空间复杂度 * 递归深度

为什么要求递归的深度呢?

因为每次递归所需的空间都被压到调用栈里(这是内存管理里面的数据结构，和算法里的栈原理是一样的)，一次递归结束，这个栈就是就是把本次递归的数据弹出去。所以这个栈最大的长度就是递归的深度。

此时可以分析这段递归的空间复杂度，从代码中可以看出每次递归所需要的空间大小都是一样的，所以每次递归中需要的空间是一个常量，并不会随着n的变化而变化，每次递归的空间复杂度就是O(1)。

在看递归的深度是多少呢?如图所示：

递归第n个斐波那契数的话，递归调用栈的深度就是n。

那么每次递归的空间复杂度是O(1)， 调用栈深度为n，所以这段递归代码的空间复杂度就是O(n)。

 
 
 
 
    
  
  
  
  
  1. int fibonacci(int i) { 
    2.   
  
  
  
  2.        if(i <= 0) return 0; 
    3.   
  
  
  
  3.        if(i == 1) return 1; 
    4.   
  
  
  
  4.        return fibonacci(i-1) + fibonacci(i-2); 
    5.   
  
  
  
  5. } 
    6.

最后对各种求斐波那契数列方法的性能做一下分析，如题：

可以看出，求斐波那契数的时候，使用递归算法并不一定是在性能上是最优的，但递归确实简化的代码层面的复杂度。

二分法(递归实现)的性能分析

带大家再分析一段二分查找的递归实现。

 
 
 
 
    
  
  
  
  
  1. int binary_search( int arr[], int l, int r, int x) { 
    2.   
  
  
  
  2.     if (r >= l) { 
    3.   
  
  
  
  3.         int mid = l + (r - l) / 2; 
    4.   
  
  
  
  4.         if (arr[mid] == x) 
    5.   
  
  
  
  5.             return mid; 
    6.   
  
  
  
  6.         if (arr[mid] > x) 
    7.   
  
  
  
  7.             return binary_search(arr, l, mid - 1, x); 
    8.   
  
  
  
  8.         return binary_search(arr, mid + 1, r, x); 
    9.   
  
  
  
  9.     } 
    10.   
  
  
  
  10.     return -1; 
    11.   
  
  
  
  11. } 
    12.

都知道二分查找的时间复杂度是O(logn)，那么递归二分查找的空间复杂度是多少呢?

我们依然看 每次递归的空间复杂度和递归的深度

首先我们先明确这里的空间复杂度里面的n是什么?二分查找的时候n就是指查找数组的长度，也就是代码中的arr数组。

每次递归的空间复杂度可以看出主要就是参数里传入的这个arr数组，即：O(n)。

再来看递归的深度，二分查找的递归深度是logn ，递归深度就是调用栈的长度，那么这段代码的空间复杂度为 n * logn = O(nlogn)。

有同学问了：为什么网上很多人说递归二分查找的空间复杂度是O(logn)，而不是O(nlogn)呢?

其实还是因为这个数组，我们可以把这个数组放到外面而不是放在递归函数参数里里，代码如下：

 
 
 
 
    
  
  
  
  
  1. int arr[] = {2, 3, 4, 5, 8, 10, 15, 17, 20}; 
    2.   
  
  
  
  2. int binary_search(int l, int r, int n) { 
    3.   
  
  
  
  3.     if (r >= l) { 
    4.   
  
  
  
  4.         int mid = l + (r - l) / 2; 
    5.   
  
  
  
  5.         if (arr[mid] == n) 
    6.   
  
  
  
  6.             return mid; 
    7.   
  
  
  
  7.         if (arr[mid] > n) 
    8.   
  
  
  
  8.             return binary_search(l, mid - 1, n); 
    9.   
  
  
  
  9.         return binary_search(mid + 1, r, n); 
    10.   
  
  
  
  10.     } 
    11.   
  
  
  
  11.     return -1; 
    12.   
  
  
  
  12. } 
    13.

看这份代码将arr数组定义为全局变量，而不放在递归循环里，那么每层递归的空间复杂度是O(1)，递归深度为O(logn)，整体空间复杂度为 1 * logn = O(logn)。

总结

本章我们详细分析了递归实现的求斐波那契和二分法的空间复杂度，同时也对时间复杂度做了分析。

特别是两种递归实现的求斐波那契数列，其时间复杂度截然不容，我们还做了实验，验证了时间复杂度为O(2^n)是非常耗时的。

通过本篇大家应该对递归算法的时间复杂度和空间复杂度有更加深刻的理解了。

新闻名称：可能对递归理解的还不够！还差得远！
本文地址：http://www.shufengxianlan.com/qtweb/news48/387598.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

定制开发知识

同城分类信息

格蓝特设备　　 　SSL认证　　 　java虚拟主机　　 　成都创新互联　　 　关键词优化　　 　成都机柜租用　　 　成都导视系统设计　　 　都江堰网站建设　　 　成都做商城网站　　 　微信小程序开发　　 　全网营销网站推广　　 　网站优化排名　　 　成都恒翔机电维修　　 　温江网站设计　　 　3D立体画　　 　网络营销推广　　 　app制作　　 　成都网站建设公司　　 　成都外贸网站建设公司　　 　网创优客