递归算法分析-分享

1. 深入认识递归

(1) 递归执行过程

   例子：求N!。
    这是一个简单的"累乘"问题，用递归算法也能解决。
    n! = n * (n - 1)!   n > 1
    0! = 1, 1! = 1      n = 0,1

    因此，递归算法如下：
   

fact(int n) {
	if(n == 0 || n == 1) 
	     return 1;
        else 
             return n * fact(n - 1);
    }

    以n=3为例，看运行过程如下：

    fact(3) ----- fact(2) ----- fact(1) ------ fact(2) -----fact(3)
    ------------------------------>  ------------------------------>
                递归                            回溯


  递归算法在运行中不断调用自身降低规模的过程，当规模降为1，即递归到fact(1)时，满足停止条件停止递归，开始回溯(返回调用算法)并计算，从fact(1)=1计算返回到fact(2);计算2*fact(1)=2返回到fact(3)；计算3*fact(2)=6，结束递归。
   算法的起始模块也是终止模块。

(2) 递归实现机制

    每一次递归调用，都用一个特殊的数据结构"栈"记录当前算法的执行状态，特别地设置地址栈，用来记录当前算法的执行位置，以备回溯时正常返回。递归模块的形式参数是普通变量，每次递归调用得到的值都是不同的，他们也是由"栈"来存储。

(3) 递归调用的几种形式

    一般递归调用有以下几种形式(其中a1、a2、b1、b2、k1、k2为常数)。

   <1> 直接简单递归调用： f(n) {...a1 * f((n - k1) / b1); ...};
   
   <2> 直接复杂递归调用： f(n) {...a1 * f((n - k1) / b1); a2 * f((n - k2) / b2); ...};

    <3> 间接递归调用：  f(n) {...a1 * f((n - k1) / b1); ...}，
                        g(n) {...a2 * f((n - k2) / b2); ...}。

2. 递归算法效率分析方法

   递归算法的分析方法比较多，最常用的便是迭代法。

  迭代法的基本步骤是先将递归算法简化为对应的递归方程，然后通过反复迭代，将递归方程的右端变换成一个级数，最后求级数的和，再估计和的渐进阶。
  <1> 例：n!
       算法的递归方程为： T(n) = T(n - 1) + O(1);
       迭代展开： T(n) = T(n - 1) + O(1)
                       = T(n - 2) + O(1) + O(1)
                       = T(n - 3) + O(1) + O(1) + O(1)
                       = ......
                       = O(1) + ... + O(1) + O(1) + O(1)
                       = n * O(1)
                       = O(n)

      这个例子的时间复杂性是线性的。

<2> 例：如下递归方程：
     
      T(n) = 2T(n/2) + 2, 且假设n=2的k次方。

      T(n) = 2T(n/2) + 2
           = 2(2T(n/2*2) + 2) + 2
           = 4T(n/2*2) + 4 + 2
           = 4(2T(n/2*2*2) + 2) + 4 + 2
           = 2*2*2T(n/2*2*2) + 8 + 4 + 2
           = ...
           = 2的(k-1)次方 * T(n/2的(i-1)次方) + $(i:1~(k-1))2的i次方
           = 2的(k-1)次方 + (2的k次方)  - 2
           = (3/2) * (2的k次方) - 2
           = (3/2) * n - 2
           = O(n)

      这个例子的时间复杂性也是线性的。


<3> 例：如下递归方程：
     
      T(n) = 2T(n/2) + O(n), 且假设n=2的k次方。

      T(n) = 2T(n/2) + O(n)
           = 2T(n/4) + 2O(n/2) + O(n)
           = ...
           = O(n) + O(n) + ... + O(n) + O(n) + O(n)
           = k * O(n)
           = O(k*n)
           = O(nlog2n) //以2为底
    
      一般地，当递归方程为T(n) = aT(n/c) + O(n), T(n)的解为：
      O(n)          (a<c && c>1)
      O(nlog2n)     (a=c && c>1) //以2为底
      O(nlogca)     (a>c && c>1) //n的(logca)次方，以c为底

   上面介绍的3种递归调用形式，比较常用的是第一种情况，第二种形式也有时出现，而第三种形式(间接递归调用)使用的较少，且算法分析
比较复杂。 下面举个第二种形式的递归调用例子。


  <4> 递归方程为：T(n) = T(n/3) + T(2n/3) + n

     为了更好的理解，先画出递归过程相应的递归树：
                            n                        --------> n
                    n/3            2n/3              --------> n
              n/9       2n/9   2n/9     4n/9         --------> n
           ......     ......  ......  .......        ......
                                                     --------
                                                     总共O(nlogn)


     累计递归树各层的非递归项的值，每一层和都等于n，从根到叶的最长路径是：
   
      n --> (2/3)n --> (4/9)n --> (12/27)n --> ... --> 1

     设最长路径为k，则应该有：
     
     (2/3)的k次方 * n = 1

     得到 k = log(2/3)n  // 以(2/3)为底

     于是 T(n) <= (K + 1) * n = n (log(2/3)n + 1)

     即 T(n) = O(nlogn)

    由此例子表明，对于第二种递归形式调用，借助于递归树，用迭代法进行算法分析是简单易行的。

评论

5 楼 dk101 2010-07-14  

楼上“love_ai87 ”提到递归太深的话，容易导致JVM内存溢出，我也遇到过此问题，这个有什么好的解决办法吗？因为递归的深度（次数），大多数时候都是根据具体数据而定，所有就很头痛了。

4 楼 agao1985 2010-06-21  

哎 递归好难啊 怎么学都学不会 太笨了我

3 楼 love_ai87 2010-06-21  

递归次数太多的话，容易栈溢出

2 楼 maozj 2010-06-21  

ivaneve 写道

引用

  1. fact(int n) { 
   2.     if(n == 0 || n == 1)  
   3.          return 0; 
   4.         else  
   5.              return n * fact(n - 1); 
   6.     } 

return 0 ? 牛的。

仔细哦 已修正

1 楼 ivaneve 2010-06-21  

引用

  1. fact(int n) { 
   2.     if(n == 0 || n == 1)  
   3.          return 0; 
   4.         else  
   5.              return n * fact(n - 1); 
   6.     } 

return 0 ? 牛的。