算法在编写成可执行程序后，运行时需要耗费时间资源和空间(内存)资源 。因此衡量一个算法的好坏，一般是从时间和空间两个维度来衡量的，即时间复杂度和空间复杂度。
时间复杂度主要衡量一个算法的运行快慢，而空间复杂度主要衡量一个算法运行所需要的额外空间。

1. 时间复杂度

1. 时间复杂度的定义：在计算机科学中，算法的时间复杂度是一个函数，它定量描述了该算法的运行时间。
2. 算法中基本操作的执行次数，为算法的时间复杂度。
3. 找到某条基本语句与问题规模N之间的数学表达式，就是算出了该算法的时间复杂度。

请计算下列代码中，Func中的++count语句总共执行了多少次？

void Func(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);
}

不难看出，++count一共执行了 N² + 2*N + 10次。
实际中我们计算时间复杂度时，我们其实并不一定要计算精确的执行次数，而只需要大概执行次数，那么这里我们使用大O的渐进表示法。

1.1 大O的渐进表示法

大O：是用于描述函数渐进行为的数学符号。
推导大O阶方法：

1. 用常数1取代运行时间中的所有加法常数。
2. 在修改后的运行次数函数中，只保留最高阶项。
3. 如果最高阶项存在且系数不是1，则去除与这个项目相乘的常数。得到的结果就是大O阶。

所以，上述代码中，Func()的时间复杂度就是：（N²） + 2*N + 10
大O的渐进表示法去掉了那些对结果影响不大的项，简洁明了的表示出了执行次数。

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

• 最坏情况：任意输入规模的最大运行次数(上界)
• 平均情况：任意输入规模的期望运行次数
• 最好情况：任意输入规模的最小运行次数(下界)

1.2 时间复杂度练习

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

上述代码的时间复杂度为O(M+N)。

// 计算BubbleSort的时间复杂度？
void BubbleSort(int* a, int n)
{
	assert(a);
	for (int j = 0; j < n - 1; j++)
	{
		int exchange = 0;
		for (int i = 0; i < n - 1 - i; i++)
		{
			if (a[i] > a[i + 1])
			{
				Swap(&a[i], &a[i + 1]);
				exchange = 1;
			}
		}
		if (exchange == 0)
			break;
	}
}

该冒泡排序

• 最好情况下：只执行O(n)次，即数据本身就有序。
• 最坏情况下：执行n-1、n-2、n-3、… 2、1，对它们进行求和，因为它是一个等差数列，所以可以表示为：
  (n-1+1)*(n-1)/2 即 (n²-n)/2 也就是O(n²)。
• 所以该函数的时间复杂度是：O(n²)

int BinarySearch(int* a, int n, int x)
 {
    assert(a);
 
    int begin = 0;
    int end = n-1;
    // [begin, end]：begin和end是左闭右闭区间，因此有=号
    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;
    }
 
    return -1;
 }

该二分查找：

• 最好情况下：中间位置就是，O(1)。
• 最坏情况下：只剩一个数或找不到，也就是让N一直除2，直到剩下一个数。
  N/2/2/2/2/2/2… == 1 除了x次。 所以N就可以表示为N= 2^x，x就等于log₂N
• 所以该函数的时间复杂度是：O(log₂N)

long long Fac(size_t N)
 {
    if(0 == N)
        return 1;
    
    return Fac(N-1)*N;
 }

该递归一共执行了N次，所以其时间复杂度为：O(N)。

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

该递归一共执行了2^N次，所以其时间复杂度为：O(2^N)。

2. 空间复杂度

空间复杂度也是一个数学表达式，是对一个算法在运行过程中临时占用存储空间大小的量度 。

• 空间复杂度不是程序占用了多少bytes的空间，因为这个也没太大意义，所以空间复杂度算的是变量的个数。
• 空间复杂度计算规则基本跟实践复杂度类似，也使用大O渐进表示法。
  • 注意：函数运行时所需要的栈空间(存储参数、局部变量、一些寄存器信息等)在编译期间已经确定好了，因此空间复杂度主要通过函数在运行时候显式申请的额外空间来确定。

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

使用了常数个额外空间，所以空间复杂度为 O(1)

// 计算Fibonacci的空间复杂度？
// 返回斐波那契数列的前n项
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;
}

动态开辟了N+1个空间，空间复杂度为 O(N)

// 计算阶乘递归Fac的空间复杂度？
long long Fac(size_t N)
 {
	 if(N == 0)
	 return 1;
	 return Fac(N-1)*N;
 }

递归调用了N次，开辟了N个栈帧，每个栈帧使用了常数个空间。空间复杂度为O(N)

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

上述求斐波那契函数的空间复杂度是多少呢?
我第一次认为是(N²)，然而它却是O(N)。为什么呢？
函数调用是在栈中形成栈帧，函数调用结束后，栈帧销毁。此栈帧占据的空间被其它函数再次使用，因此函数只申请了N-1个空间，所以空间复杂度为O(N)。

到这里我们可以知道：时间是一去不复返的；空间是可以重复利用的。