数据结构_时间复杂度和空间复杂度

从程序设计的角度来看，时间复杂度和空间复杂度是评价一个算法性能的重要指标，因此，估算一个算法的时间复杂度和空间复杂度是程序员必须掌握的能力。这篇博客将会整理相关知识点，并且举例说明。

时间复杂度

定义

时间复杂度： 在计算机科学中，算法的时间复杂度(Time complexity)是一个函数，它定量描述了该算法的运行时间。
一个算法执行所耗费的时间，从理论上说，是不能算出来的，只有你把你的程序放在机器上跑起来，才能知道。但是我们需要每个算法都上机测试吗？是可以都上机测试，但是这很麻烦，所以才有了时间复杂度这个分析方式。
一个算法所花费的时间与其中语句的执行次数成正比例，算法中的基本操作的执行次数，为算法的时间复杂度。即：找到某条基本语句与问题规模N之间的数学表达式，就是算出了该算法的时间复杂度。

时间复杂度有三种情况：

1. 最好情况：任意输入规模的最小运行次数(下界)
2. 平均情况：任意输入规模的期望（平均）运行次数
3. 最差情况：任意输入规模的最大运行次数(上界)

在实际应用中，我们主要关注的是最差情况（类似于木桶原理一样），我们的算法要想具有很强实用性，那当然得能处理所有情况。

解释

时间复杂度本质上是一个计算算法运行时间的函数，但是算法运行时间取决于运行算法的计算机，我们无法从理论上算出一个算法的运行时间，但是计算机对于基本语句（例如加法）的运算时间是一样的，算法运行的总时间和基本语句的执行次数最多差一个常数系数，所以在通常情况下：计算时间复杂度就是计算算法中基本语句（基本单元）的运行次数。

大O渐近表示法

我们计算基本语句的运行的总次数时，没必要计算出精确的次数，只需要估算个大概就行了，只要我们估算的次数和精确次数处于同一个数量级，那么对于计算机的运行速度来说，最终的算法运行时间相差会很小。因此使用大O渐近表示法¹ 来表示时间复杂度。

规则：

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

举一个例子

    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
        {
            c[i][j] = 0; // 执行n*n次
            for (int k = 0; k < n; k++)
            {
                c[i][j] = c[i][j] + 1; // 执行n*n*n次
                c[i][j] = c[i][j] + 1; // 执行n*n*n次
        }
    }

我们用f(n)表示基本语句执行总次数，所以上述代码中：f(n) = n²+2*n³，根据大O表示法的规则，我们去掉n²这一项，去掉n³前面的系数，所以上面算法的时间复杂度为：O(n³).

为什么大O表示法可以估算执行次数？
就拿上面的代码来说，n = 10时，精确的执行次数 f(n) = f(10) = 100 + 2000 = 2100，这个结果是处在1000这个量级的，我们忽略掉100和系数2，他还是处于1000这个量级。因此大O表示法是可以大概估算出执行次数的。

总结： 我们想用算法中基本语句的大概执行次数来描述时间复杂度，因此使用大O表示法来表示时间复杂度。大O表示法就是保留对结果影响最大的项，将影响小的项忽略掉。

经典例子

折半查找的时间复杂度

void find(int* arr, int sz, int x)
{
	int left = 0;
	int right = sz - 1;

	while (left <= right)
	{
		int middle = (left + right) / 2;
		if (arr[middle] > x)
		{
			right = middle - 1;
		}
		else if (arr[middle] < x)
		{
			left = middle + 1;
		}
		else
		{
			printf("找到了！ a[%d]=%d\n", middle, x);
			break;
		}
	}
	if (left > right)
	{
		printf("找不到！");
	}
}

折半查找就是在N个有序数列中找一个数，每次把这个N个数分成两半，判断这个数处于哪一半中，然后一直折半直到找到这个数。假设我们要在0~9中找到9，根据上面的代码，画出查找的过程如下图：

在最坏的情况下，折半到只剩下一个元素了才找到要查的数字，这个时候 $N/2/2/2/.../2=1$ ，除了多少次2，就找了多少次，也就是说基本语句执行了多少次，那么时间复杂度就是 $O(Lo{g}_{2}N)$ 在时间复杂度中，一般简写为$O(LogN)$.

计算阶乘的递归函数的时间复杂度

int times(int n)
{
    if (n == 0 || n == 1)
    {
        return 1;
    }

    return n * times(n - 1);
}

$$递归算法的时间复杂度=递归次数\times 每次递归函数中的计算次数$$
显然计算N的阶乘需要递归N-1次，每次计算1次，所以时间复杂度为$O(N)$

斐波那契递归函数的时间复杂度

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

假设像细胞分裂一样展开，那么时间复杂度为：$2^0+2^1+\dots \dots +2^{N-1}=2^N-1$，这里用到了等比数列前n项和公式：$$S_n=\frac{a_1\times (1-q^n)}{1-q}=\frac{2^0(1-2^n)}{1-2}=2^N-1.$$实际上展开的分支很多提前就结束了。因此时间复杂度为$O(2^N)$.

空间复杂度

定义

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

举例

冒泡排序

void  BubbleSort(int arr[], int n)
{
	for (int i = 0; i < n - 1; i++)
	{
		for (int j = 0; j < n - i - 1; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}

分析： 冒泡排序中，变量i和j占用一个空间，变量tmp处于if函数的作用域中，每次进入if后会tmp被创建，出if后被销毁，所以tmp相当于占用一个空间。因此冒泡排序需要的额外空间是常数个，空间复杂度用大O表示法表示为$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-1)次，所以空间复杂度是$O(N)$.

---

1. 大O符号（Big O notation）：是用于描述函数渐进行为的数学符号。 ↩︎