浅析时间复杂度和空间复杂度

一个算法的优劣主要从算法的执行时间和所需要占用的存储空间两个方面衡量。
即用空间复杂度和时间复杂度来衡量。

下面，就是博主对空间复杂度和时间复杂度的浅析。

空间复杂度(Space Complexity)

什么是空间复杂度？
空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度，记做S(n)=O(f(n))。
注意： 空间复杂度不是程序占用了多少bytes的空间，因为这个也没太大意义，所以空间复杂度算的是变量的个数。

空间复杂度的表示方法： 大O渐进表示法。大O表示法释义(引用)

//计算BubbleSort算法的空间复杂度
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(1);

// 计算Fibonacci的空间复杂度
long long* Fibonacci(size_t n)
{
	if(n==0)
	   return NULL;
	   
	long long * fibArray = new long long[ n+1];
 	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);

// 计算阶乘递归Factorial的时间复杂
long long Factorial(size_t N)
{
 return N < 2 ? N : Factorial(N-1)*N;
}

该算法递归调用了N次，开辟了N个栈帧，每个栈帧使用了常数个空间，所以空间复杂度为 O(N)；

经过计算机行业的迅速发展，计算机的存储容量已经达到了很高的程度。所以我们如今已经不需要再特别关注一个算法的空间复杂度，因此大都常用用空间换时间的方法来提高效率；

时间复杂度(Time Complexity)

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

实际中我们计算时间复杂度时，我们其实并不一定要计算精确的执行次数，而只需要大概执行次数，那么这里我们使用大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);
}

该算法的基本操作执行了2N+10次，通过推导大O阶方法知道，时间复杂度为 O(N)；

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

该算法的基本操作执行了M+N次，有两个未知数M和N，时间复杂度为 O(N+M)；

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

该算法的基本操作执行了10次，通过推导大O阶方法，时间复杂度为 O(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;
	}
}

该算法的基本操作执行最好N次，最坏执行了(N*(N+1)/2次，通过推导大O阶方法+时间复杂度一般看最坏，时间复杂度为 O(N^2)；

以上就是博主对时间复杂度和空间复杂度的浅层的理解，如有错误，还望不吝指出！