算法的时间复杂度和空间复杂度

目录

前沿：

1. 算法效率

1.1. 算法的复杂度

2. 时间复杂度

2.1 时间复杂度的概念

2.2 大O的渐进表示法

时间复杂度的举例：

3. 空间复杂度

空间复杂度的举例：

---

前沿：

此博客从3大点入手:

1. 算法效率
2. 时间复杂度
3. 空间复杂度

---

1. 算法效率

1.1. 算法的复杂度

算法在编程可执行程序后，运行时所需要耗费的时间资源和空间资源。因此衡量一个算法的好坏，一般是从时间和空间两个纬度来衡量的，即时间复杂度与空间复杂度。

注：时间复杂度主要衡量的是一个算法的运行快慢，而空间复杂度主要衡量一个算法运行所需要的额外空间。

（其实对于空间复杂度要求性，主要是计算机发展的前期，因为计算机的内存容量很小。所以很在乎，但是如今科技的飞速发展下，计算机的内存容量已经到了一个很高的程度，所以也就没这么重要了，只不过对于能力的凸现上，还是重要的）

2. 时间复杂度

2.1 时间复杂度的概念

时间复杂度的定义：算法的时间复杂度是一个函数，它用来定量的描述了该算法的运行时间。（其所存在的意义：其实一个算法执行所耗费的时间是不能算出来的，为了知道一个算法的运行速度，就要写出然后放在机器上跑起来，并且我们要知道，同样的算法在不同的编译器中执行，所耗费的时间也是不同的。这是很麻烦的，所以才有了时间复杂度这个分析方式）。

算法中的基本操作的执行次数，为算法的时间复杂度。

接下来我们看看这样一个代码：

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

注意：找到基本语句的问题规模（执行次数）N之间的数学表达式，就是算出了该算法的时间复杂度。

fun函数的基本操作次数：

 F（N）=  N^2 + 2*N + 10

但是这是能称作为基本执行次数，并不能称作为时间复杂度，毕竟，在实际中这样的计算方式其实是不必要的，随着计算机的快速发展，大部分的计算机的单秒计算量应该都在10^7~10^9之间。

• N = 10   F(N) = 130
• N = 100             F(N) = 10210
• N = 1000           F(N) = 1002010

所以我们其实不需要计算精准的计算次数即可，而只需要大概执行次数，那么这里我们使用大O的渐进表示法。

2.2 大O的渐进表示法

大O符号（Big O notation）：是用于描述函数渐进行为的数字符号。

推导大O阶方法：

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

使用大O的渐进表示法以后，fun函数的时间复杂度为：

O(N^2)

因为正如我们前面所说：

• N = 10                F(N) = 130
• N = 100              F(N) = 10210
• N = 1000            F(N) = 1002010

我们可以发现，在F(N) = N^2 + 2*N + 10中，在足够大的N下，(2*N + 10)其实对结果的影响根本就不大，正如此大O的渐进表示法去掉了那些对结果影响不大的项，简洁明了的表示出了执行次数。

同时，有一些算法的时间复杂度存在最好，平均和最坏情况。

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

(注意：在实际中一般情况关注的是算法的最坏运行情况)

时间复杂度的举例：

1.

int BinarySearch(int* a, int len, int x)
{
	assert(a);

	int begin = 0;
	int end = len - 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;
	}

	return -1;
}

我们可以发现这其实就是折半的查找的方式（相当于一张很长的纸，我们将其按照单位划分，然后通过将纸张折半的方式缩小数据范围），我们这种判断的方式是通过判断中间值大于还是小于目标值，所以最好的莫非于第一次的中间值就是目标值，最坏的莫非于，我们折半到只剩最后一个数值。即：基本操作执行最好为1次，最坏O(logN)次，时间复杂度为O(logN)（ps：logN在算法分析中表示是底数为2，对数为N，有些地方会写成lgN）。

3. 空间复杂度

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

空间复杂度与时间复杂度是一样的，空间不是准确的计算占用了多少byte的空间，这同样是没有多大意义的，所以空间复杂度是变量的个数，同样也是使用大O渐进法。

（注意：函数运行时所需要的栈空间(存储参数、局部变量、一些寄存器信息等)在编译期间已经确定好了，因此空间复杂度主要通过函数在运行时候显式申请的额外空间来确定。）

空间复杂度的举例：

1.

//斐波那契数列前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个空间，空间复杂度为O(N)。

2.

//计算斐波那契递归Fib的空间复杂度
long long Fib(size_t N)
{
	if(N < 3)
	return 1;

	return Fib(N - 1) + Fib(N - 2);
}

此空间复杂度需要注意：时间是累计的。但是，空间是不累计的，可以重复利用。