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

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

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

 一、时间复杂度

int function(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 mum = 10;

	while (mum)
	{
		count++;
		mum--;
	}
}

function函数里执行的基本操作次数：F(N) = N*N + 2*N + 10

计算时间复杂度时,并不一定要计算精确的执行次数,而只需要大概执行次数,这里就要使用大O的渐进表示法。

1.大O的渐进表示法

推导大 O 阶方法：

1、用常数1取代运行时间中的所有加法 常数 。

2、在修改后的运行次数函数中， 只保留最高阶项 。

3、如果最高阶项存在且不是1，则 去除与这个项目相乘的常数 。得到的结果就是大O阶。

如上 function函数的时间复杂度为 O(n²)

大O的渐进表示法 去掉了那些对结果影响不大的项 ，简洁明了的表示出了执行次数。

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

最坏情况：任意输入规模的最大运行次数(上界)

平均情况：任意输入规模的期望运行次数

最好情况：任意输入规模的最小运行次数(下界)

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

2. 常见时间复杂度计算举例

1.

void function(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(N+M)

注意：

1. M (N) 远大于N (M) 时，时间复杂度为O(M)  (O(N))

2. M和N差不多大时 ，时间复杂度为O(M) 或 O(N)

2.

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

时间复杂度： O(1)

3. 计算strchr函数的时间复杂度

const char * strchr ( const char * str, int character );

完整的strchr函数:

const char* strchr(const char* str, int character)
{
	while (*str)
	{
		if (*str == character)
		{
			return str;
		}
		else
			str++;
	}
	return NULL;
}

时间复杂度：O(N)

4. 计算BubbleSort函数的时间复杂度

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

F(N) = (1+2+3......+N) = N(N-1)/2 = N²/2 - N/2    等差数列求和

时间复杂度：O(N²)

5.计算BinarySearch的时间复杂度

int BinarySearch(int* a, int n, int x) 
{
	assert(a);
	int left = 0;
	int right = n - 1;
	while (left <= right)
	{
		int mid = left + ((right - left) >> 1);//防止相加数据过大溢出
		//原 mid = (left +right)/2 
		//((right - left) >>1 ) = ((right - left) * 2)
		//left + ((right - left) >> 1) = left + right/2 - left/2 = left/2 + right/2 = (right +left)/2
		if (a[mid] < x)
			left = mid + 1;
		else if (a[mid] > x)
			right = mid - 1;
		else
			return mid;
	}
	return -1;
}

F(N) =  ㏒₂N

时间复杂度：O(logN)      (有的资料会简写成 O( lgN ) ,这个是不太对，存在误区)

二分法查找还有注意区间问题而改变

左闭右闭

int BinarySearch(int* a, int n, int x) 
{
	assert(a);
	int left = 0;
	int right = n - 1;
	while (left <= right)
	{
		int mid = left + ((right - left) >> 1);
		if (a[mid] < x)
			left = mid + 1;
		else if (a[mid] > x)
			right = mid - 1;
		else
			return mid;
	}
	return -1;
}

左闭右开

int BinarySearch(int* a, int n, int x) 
{
	assert(a);
	int left = 0;
	int right = n ;//此处右区间为开，所以数组下标不取n-1，往后取一位
	while (left < right)
	{
		int mid = left + ((right - left) >> 1);
		if (a[mid] < x)
			left = mid + 1;
		else if (a[mid] > x)
			right = mid ;//此处右区间为开，数组下标往后取一位，以便能取到原 mid-1
		else
			return mid;
	}
	return -1;
}

 

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

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

时间复杂度：O(N)

递归算法时间复杂度计算规则：

1.每次函数调用时O(1)，那么就看它的递归次数

2.每次函数调用不是O(1)，那么就看他的递归调用中次数的累加

改造后：

long long Fac(size_t N) 
{
	if (0 == N)
		return 1;
	for (int i = 0; i < N; i++)
	{
		printf("%d ", i);
	}
	return Fac(N - 1) * N;
}

改造后符合上面规则2 ，  F(N) = N+(N-1)+(N-2)+(N-3)......+1 = N*(N-1)/2 

时间复杂度：O(N²)

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

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

时间复杂度：O(2ⁿ)  （二叉树）

---

二、空间复杂度

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

空间复杂度不是程序占用了多少 bytes 的空间，因为这个也没太大意义，所以空间复杂度算的是 变量的个数

空间复杂度计算规则基本跟实践复杂度类似，也使用 大 O 渐进表示法

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

常见空间复杂度计算举例

1.

void BubbleSort(int* a, int n) {
	assert(a);
	for (int j = n; j > 0; j--) //创建变量 j
	{
		int exchange = 0; //创建变量 exchange
		for (int i = 1; i < j; i++) //创建变量 i
		{
			if (a[i - 1] > a[i])
			{
				int tmp = a[i - 1]; //创建变量 tmp
				a[i - 1] = a[i];
				a[i] = tmp;
				exchange = 1;
			}
		}
		if (exchange == 0)
			break;
	}
}

空间复杂度：O(1)

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

2.

int test(int* nums, int numsSize)
{
	int* a = (int*)malloc(sizeof(int) * numsSize);//numsSize未确定
	return 0;
}

时间复杂度：O(N)

int test(int* nums, int numsSize)
{
	int* a = (int*)malloc(sizeof(int) * 20);//20是常数
	return 0;
}

时间复杂度：O(1)

3.计算Fibonacci的空间复杂度

//返回斐波那契数列的前n项
long long* Fibonacci(int n) {
	if (n == 0)
		return NULL;

	long long* fibArray = (long long*)malloc((n + 1) * sizeof(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;
}

空间复杂度：O(N)

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

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

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

空间复杂度：O(N)

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

---