时间复杂度和空间复杂度

时间复杂度：

定义：

在计算机科学中，算法的时间复杂度是一个函数，它定量描述了该算法的运行时间。

一个算法执行所耗费的时间，从理论上说，是不能算出来的，只有你把你的程序放在机器上跑起来，才能知道。但是我们需要每个算法都上机测试吗？是可以都上机测试，但是这很麻烦，所以才有了时间复杂度这个分析方式。一个算法所花费的时间与其中语句的执行次数成正比，算法中的基本操作的执行次数，为算法的时间复杂度。

注：上述所指函数，是数学当中的函数

分析以下代码的执行次数：

void Func1(int N)
{
    int count = 0;
    for (int i = 0; i < N; ++i)
    {
        for (int j = 0; j < N; ++j)
        {
            ++count;
        }
    }
    for (int k = 0; k < 2 * N; ++k)
    {
        ++count;
    }
    int M = 10;
    while (M--)
    {
        ++count;
    }
    printf("%d\n", count);
}
int main()
{
    Func1(10);
	return 0;
}

时间复杂度的函数式：F(N)=N*N+2*N+10

N越大，后两项对结果的影响越小

实际中我们计算时间复杂度时，我们其实并不一定要计算精确的执行次数，而只需要大概执行次数，那么这里我们使用大O的渐进表示法。

大O的渐进表示法：

推导大O阶的基本方法：

1.用常数1取代运行时间中的所有加法常数。

void Func2(int N)
{
    int count = 0;
    for (int k = 0; k < 100; ++k)
    {
        ++count;
    }
    printf("%d\n", count);
}

此代码的时间复杂度为O(1),O(1)并不代表只执行一次，而是执行常数次

2.在修改后的运行次数函数中，只保留最高阶项。

3.如果最高阶项存在且不是1，则去除与这个项目相乘的常数。得到的结果就是大O阶（如果有常数项除去常数项）

void Func2(int N)
{
    int count = 0;
 
    for (int k = 0; k < 2 * N ; ++ k)
    {
        ++count;
    }
 
    int M = 10;
 
    while (M--)
    {
        ++count;
    }
 
    printf("%d\n", count);
}

上述代码时间复杂度为O(N)

另外有些算法的时间复杂度存在最好、平均和最坏情况：

最坏情况：任意输入规模的最大运行次数(上界)

平均情况：任意输入规模的期望运行次数

最好情况：任意输入规模的最小运行次数(下界)

例如：在一个有N个数据的数组当中，查找一个数字Y：

最好情况：1次找到

最坏情况：N次找到

平均情况：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;
    }
}

上述代码为冒泡排序：时间复杂度则为O(N^2)

因为冒泡排序，第一次排序需要n-1，第二次为n-2，依次类推到最后一个数，相加也就是等差数列的和。

例：二分查找

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 - 1;
        else
            return mid;
    }
}

二分查找每次能查找一半，因此第一次查找N/2，第二次就是N/2的二分之一，依此类推，最后剩一个数，相加为等比数列求和

空间复杂度：

定义：空间复杂度是算法在运行过程中临时占用存储空间大小的量度 。

例如：上述代码冒泡排序空间复杂度为O(1)

long long Fib(size_t N)
{
    if (N < 3)
        return 1;
    return Fib(N - 1) + Fib(N - 2);
}

该代码的空间复杂度为O(N)

空间是可以重复利用的，不累计的

时间则是一去不复返，累计的