什么是时间复杂度和空间复杂度

时间复杂度和空间复杂度是衡量算法效率的两个角度

算法效率

时间复杂度(也称为时间效率)衡量一个算法运行所需的时间；
空间复杂度(也称为空间效率)衡量一个算法运行所需的空间。

时间复杂度

一个算法所花费的时间与其中语句的执行次数成正比例，算法中的基本操作的执行次数，为算法的时间复杂度。

计算规则：
1、用常数1取代运行时间中的所有加法常数。
2、在修改后的运行次数函数中，只保留最高阶项。
3、如果最高阶项存在且不是1，则去除与这个项目相乘的常数。

常见算法的时间复杂度计算

1.字符串查找

void my_strchr(char* str,char c)
{
    while (*str != '\0')
    {
        if (*str == c)
        {
            return str;
        }
        str++;
    }
}

通常假设数组或字符串的长度为N，但不知道什么时候能够在字符串中找到需要寻找的元素，或许在第一个位置就找到了，也有可能要遍历整个字符串在最后一个元素的位置才能找到
则默认时间复杂度要以最坏的情况为准，即O(N)。

2.冒泡排序

void BubbleSort(int* a, int n) 
{
    assert(a);
    for (size_t end = n; end > 0; --end) 
    {
        int exchange = 0;
        for (size_t i = 1; i < end; ++i)
        {
            if (a[i - 1] > a[i])
            {
                Swap(&a[i - 1], &a[i]);
                exchange = 1;
            }
        }
        if (exchange == 0)
            break;
    }
}

首先要进行N次排序，然后在每次排序时又要遍历这个数组，每进行一次排序，下一次排序时就可以少遍历一个元素
运算次数F(N)=N+(N-1)+(N-2)……+2+1
这是一个等差数列，结果化简为F(N)=N*(N+1)/2
因此时间复杂度为O(N²)

3.二分法查找

int BinarySearch(int* a, int n, int x) 
{
    assert(a);
    int begin = 0;
    int end = n - 1;
    while (begin < end) 
    {
        int mid = begin + ((end - begin) >> 1);
        if (a[mid] < x)
            begin = mid + 1;
        else if (a[mid] > x)
            end = mid;
        else
            return mid;
    }
    return -1;
}

二分法查找：每次都取数组的中间值，再根据中间值与查找值的大小来确定要查找的元素在哪一半，再对找到的那一半数组进行重复的操作，直到找到。
默认时间复杂度要以最坏的情况为准，即把数组除的只剩最后一个元素，这时表达式为N÷2÷2÷2÷2…÷2÷2=1
把这个式子换算一下为N=1×2×2×2…×2×2
所以时间复杂度为O(log₂N)。

4.递归方法计算斐波那契数列

long long Fibonacci(size_t N) 
{
    return N < 2 ? N : Fibonacci(N-1)+Fibonacci(N-2);
}

上面的代码是一个计算斐波那契数列的函数，使用的是递归的方法
该算法的时间按复杂度为O(2^N)

空间复杂度

空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度 。即空间复杂度算的是变量的个数。

常见算法的时间复杂度计算

1.冒泡排序

void BubbleSort(int* a, int n) 
{
     assert(a);
     for (size_t end = n; end > 0; --end)
     {
         int exchange = 0;
         for (size_t i = 1; i < end; ++i)
         {
             if (a[i-1] > a[i])
             {
                 Swap(&a[i-1], &a[i]);
                 exchange = 1;
             }
         }
         if (exchange == 0)
         break;
     }
}

这个冒泡排序算法创建了3个变量，根据大O的渐进表示法的规则，该算法的空间复杂度就为O(1)。

2.循环方法计算斐波那契数列

long long* Fibonacci(size_t n) 
{
    if (n == 0)
        return NULL;

    long long* fibArray =(long long*)malloc((n + 1) * sizeof(long long));
    fibArray[0] = 0;
    fibArray[1] = 1; for (int i = 2; i <= n; ++i)
    {
        fibArray[i] = fibArray[i - 1] + fibArray[i - 2];
    }
    return fibArray;
}

在这个算法中，我们使用malloc开辟了一块元素个数为n+1的空间，那就相当于创建了n+1个变量，根据大O的线性表示法，该算法的空间复杂度就为O(N)。

3.递归方法计算斐波那契数列

long long Factorial(size_t N) 
{
     return N < 2 ? N : Factorial(N-1)*N; 
}

在调用函数时，会创建栈帧，简单来说每调用一次函数，就会为调用的那个函数创建一块空间。在计算递归算法的空间复杂度时，可以认为每次函数调用时都会创建常数个变量，那么影响我们算法空间复杂度的就是我们调用递归的次数。
那么以上面的算法为例，该算法的空间复杂度就是O(N)。
递归算法的空间复杂度通常是递归的深度

空间复杂度一般只有两种情况：
–创建了常数个变量：O(1)
–创建了N个变量：O(N)