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

衡量一个算法的好坏，一般是从时间和空间两个维度来衡量的，即时间复杂度和空间复杂度

---

时间复杂度

1）概念

算法的时间复杂度是一个函数 ，算法中的基本操作的执行次数，为算法的时间复杂度

2）大O的渐进表示法

大O符号（Big O notation）
方法：

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

当O(M+N)时可写为O(max(M,N)):

1. 当M远大于N时记作O(M)
2. 当N远大于M时记作O(N)

例如：N^2+2*N+10的时间复杂度为：2N

3）最好、平均和最坏情况

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

---

例：在一个长度为N数组中搜索一个数据n
最好情况：1次
平均情况：N/2次
最坏情况：N次

4）例题

1.计算Func4的时间复杂度

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

分析：用方法一，常数次为O(1)

2.计算阶乘递归Fac的时间复杂度

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

递归算法的时间复杂度计算：递归次数N乘以每次递归调用中的次数
分析：

1. 每次递归调用中只有一个return 1，为一
2. 从N，N-1，N-2，…，1一共N次

所以阶乘递归Fac的时间复杂度O(N*1)=O(N)

3.计算斐波那契递归Fib的时间复杂度

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

分析如上图：共需2^0+2^1+2^2+...+2^(N-2)次,用等比数列算出为2^(N-1)-1次，用大O的渐进表示法表示为O(2^N)

4.计算BinarySearch的时间复杂度

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

分析如图：最后N/2/2/2/2.../2=1设有x个2则N=2^x，x=log(N)/log(2)，用大O的渐进表示法表示为O(logN)
基本操作执行最好1次，最坏O(logN)次，时间复杂度为 O(logN)

5.计算建堆的时间复杂度

void AdjustDown(int* array, int n, int parent)//向下调整算法
{
	int child = parent * 2 + 1;
	while (child<n)
	{
		if (child < n-1 && array[child] > array[child + 1])
		{
			child++;
		}
		if (array[parent] > array[child])
		{
			int tmp = array[parent];
			array[parent] = array[child];
			array[child] = tmp;
			//以下两句要放在if内因为child作为循环判断结束标志
			parent = child;
			child = parent * 2 + 1;
		}
		else
			break;
	}
}
void HeapSort(int* array, int n)
{//建队
	for (int i = (n - 1 - 1) / 2; i >= 0; --i)
	{
		AdjustDown(array, n, i);
	}
}

分析如图：

1. 错位相减法，化简得T(n)= 1-h+2^1+2^2+2^3+2^4+...+2^(h-2)+2^(h-1)
2. 再化简得T(n)=2^0 +2^1 +2^2 +2^3 +2^4 +...+2^(h-2)+ 2^(h-1)-h
3. 等比数列求和T(n)=2^(h-1)-h，结合n=2^h- 1和h= log2(n+ 1)
4. 得出结论T(n)=n- log2(n+1)≈n，时间复杂度为O(N)

---

空间复杂度

1）概念

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

2）例题

1.计算阶乘递归Fac的空间复杂度

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

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

2.计算斐波那契递归Fib的空间复杂度

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

分析如图：每调用一次递归会占用空间调用完后会销毁空间再进行下一次递归，如此实际只占用了N个空间，空间复杂度为O(N)
时间累计，空间不累计

常见复杂度

5201314	O(1)	常数阶
3n+4	O(n)	线性阶
3n^2+4n+5	O(n^2)	平方阶
3log(2)n+4	O(logn)	对数阶（速度和常数阶相差不大）
2n+ 3nlog(2)n+14	O(nlogn)	nlogn阶
n^3+2n^2+4n+6	O(n^3)	立方阶
2^n	O(2^n)	指数阶