算法复杂度

算法复杂度分为时间复杂度和空间复杂度

---

时间复杂度

时间复杂度是指执行算法所需要的计算工作量。
来看下面的例子：

void Test(int n)
{
    int iCount = 0;
    for(int i = 0; i < n; ++i)
    {
        for(int j = 0; j < n; ++j)
        {
            iCount++;
        }
    }
    
    for(int k = 0; k < 2*n; ++k)
    {
        iCount++;
    }
    
    int count = 10;
    while(count--)
    {
        iCount++;
    }
    
}

该算法语句的总执行次数为：f(n) = n²+2n+10；

一般使用O渐进表示法来计算算法的时间复杂度。

• 定义：如果一个问题的规模是n，解这一问题的某一算法所需要的时间为T(n)，它是n的某一函数。T(n)称为这一算法的“时间复杂度”。当输入量n逐渐加大时，时间复杂度的极限情形称为算法的“渐近时间复杂度”。

一般算法O(n)计算方法为：

1. 用常数1取代运行时间中的所有加法常数。
2. 在修改后的运行函数中，只保留最高项。
3. 如果最高项存在且不是1，则去除这项相乘的常数。

所以上面算法的时间复杂度为：O(n²)。

• 常见的时间复杂度：

算法的执行次数	时间复杂度
12	O(1)
2n+3	O(n)
3n²+2n+1	O(n²)
5log2n+20	O( log(n) )
2n+3nlog2n+19	O( nlog(n) )
6n³+2n²+3n+4	O(n³)
2n	O(2n)

常用的时间复杂度所消耗的时间从小到大依次为：
O(1)<O( log(n) )<O(n)<O( nlog(n) )<O(n²)<O(n³)<O(2ⁿ)<O(n!)<O(nⁿ)

算法存在最好、平均和最坏情况：
最坏情况：任意输入规模的最大运行次数(上界)
平均情况：任意输入规模的期望运行次数
最好情况：任意输入规模的最小运行次数，通常最好情况不会出现 (下界)

例如：在一个长度为N的线性表中搜索一个数据x
最好情况：1次比较
最坏情况：N次比较
平均情况：N/2次比较

在实际中通常关注的是算法的最坏运行情况，即：任意输入规模N，算法的最长运行时间。理由如下：
一个算法的最坏情况的运行时间是在任意输入下的运行时间上界；
对于某些算法，最坏的情况出现的较为频繁；
大体上看，平均情况与最坏情况一样差。

---

空间复杂度

空间复杂度是指执行这个算法所需要的内存空间。

空间复杂度(SpaceComplexity)是对一个算法在运行过程中临时占用存储空间大小的量度。一个算法在计算机存储器上所占用的存储空间，包括存储算法本身所占用的存储空间，算法的输入输出数据所占用的存储空间和算法在运行过程中临时占用的存储空间这三个方面。

int Sum(int N)
{
    int count = 0;
    for(int i = 1; i <= N; ++i)
        count += i;
    return count;
}

该算法仅创建了常数变量，空间复杂度为：O(1)；

---

二分查找递归与非递归算法

找到了返回下标，没找到返回 -1

递归算法：

int RecursionBinarySearch(int arr[], int k, int left, int right){
    int mid = left+(right-left)/2;
    if(left > right){
        return -1;
    }
    
    if(k == arr[mid]){
        return mid;
    }
    else if(k > arr[mid]){
        return RecursionBinarySearch(arr, k, mid+1, right);
    }
    else{
        return RecursionBinarySearch(arr, k, left, mid-1);
    }
}

递归的二分查找的空间复杂度为递归的总次数乘以每次递归所需要的辅助空间，这里递归的次数为 log2ⁿ ，每次递归所需要的辅助空间为常数，因此空间复杂度：O( log2ⁿ ) ； 所有语句的执行次数为递归的次数乘以每次递归语句的执行次数，每次递归语句的执行次数为常数，所以时间复杂度为O( log2ⁿ ) 。

时间复杂度：O( log2ⁿ )
空间复杂度：O( log2ⁿ )

非递归算法：

int BinarySearch(int arr[], int k, int size){
    int left = 0;
    int right = size-1;
    while(left <= right){
        int mid = left+(right-left)/2;
        if(k == arr[mid]){
            return mid;
        }
        else if(k > arr[mid]){
            left = mid+1;
        }
        else{
            right = mid-1;
        }
    }
    return -1;
}

非递归的二分查找的时间复杂度即为while循环的次数，设找了x次找到，那么2^x=n，则x=log2ⁿ，即时间复杂度为O( log2ⁿ )；因为该算法仅创建了常数的变量，所以空间复杂度为O(1)。

时间复杂度：O( log2ⁿ )
空间复杂度：O(1)

---

斐波那契额数列的递归与非递归算法

递归算法：

int Fib(int n){
    if(n<3){
        return 1;
    }
    else{
        return Fib(n-1)+Fib(n-2);
    }
}

递归的时间复杂度就是该二叉树的节点数，因为我们只关心增长趋势，可近似的看成满二叉树，节点个数为2ⁿ-1，因此时间复杂度为O(2ⁿ) ；空间复杂度为递归到最深处的栈所开辟的空间数量，当递归到达最深处的时候，栈会销毁，释放空间，再计算+后面的式子，因此空间复杂度为O(n)

时间复杂度：O(2ⁿ)
空间复杂度：O(n)

非递归算法

int Fib_(int n){
    int n1 = 1;
    int n2 = 1;
    int n3 = 0;
    for(int i=3; i<=n; i++){
        n3 = n1+n2;
        n1 = n2;
        n2 = n3;
    }
    return n3;
}

非递归算法的时间复杂度为for循环的次数，即时间复杂度为O(n)；因为仅创建了常数个变量，所以空间复杂度为O(1)。

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