关于《算法》递归算法复杂度分析

写在前面的话：不是有递归函数复杂度就是O(nLogn)。

还是要具体问题具体分析。

如果递归函数中，只进行一次递归调用，递归的深度为depth；

在每个调用中时间复杂度为T，则总的时间复杂度为O（T*depth)；

double pow(double x, int n){
        assert(n>=0);//此处如果n<0怎么改写才能够得到同样的结果
        
        if( n==0)
            return 1.0;
        
        double t = pow(x,n/2);
        if( n%2 )
            return x*t*t;
        return t*t;
    }

递归深度：logn

时间复杂度：O（Logn）

递归中进行多次的递归调用,以下例子以两次递归调用为例：

//递归中进行多次的递归调用
    int f(int n){
        assert( n >=0);
        if( n==0)
            return 1;
        return f(n-1)+f(n-1);
    }

计算调用的次数，递归的深度和调用的次数在此方面就是两个概念了。

我们可以用动态规划算法把一个指数级别的算法转换成一个多项式级别的算法问题。

在很多时候我们的归并排序算法是O(nLogn)级别的算法，以下面代码为例子：

    void mergeSort(int arr[],int l,int r){
        if( l>= r ){
            return;
            
            int mid = (l+r)/2;
            mergeSort(arr,l,mid);
            mergeSort(arr,mid+1,r);
            mergeSort(arr,l,mid,r);
        }

在这些排序算法中我们在每一个节点所处理的数据规模是逐渐缩小的，我在上文举得例子每个节点的数据规模都是一样的，在每一层上处理的数据节点都是Logn一共有n个节点所以得到的结果就是O（nLogn）级别。

这一棵递归树就是分治算法的结果。

递归算法的时间复杂度还有一个额外的理论就是主定理——归纳了递归函数所计算时间复杂度所有的情况。一个递归函数把一个数据分成几份进行递归，每个递归所拥有的时间复杂度是怎么样，这是一个能够让自己很好的获得该算法的时间复杂度的方法。