时间复杂度&空间复杂度

本章目标

• 算法效率
• 时间复杂度
• 空间复杂度
• 常见时间复杂度oj练习

1.时间复杂度

1.1时间复杂度的概念

算法的时间复杂度是一个函数（带未知数的数学表达式，不是C语言中的函数）。
处理时间复杂度问题，即，找到基本语句与问题规模N之间的数学表达式，就是算出了该算法的时间复杂度。
例题：

//请计算：Func1中++count语句总共执行了多少次？
void Func1(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;
}

计算结果：F(N)=N*\N+2N+10

• N = 10 F(N) = 130
• N = 100 F(N) = 10000
• N = 1000 F(N) = 100000
  实际中，在我们计算时间复杂度时，并不一定要计算精确的执行次数，我们不关心硬件，而只需要大概执行次数，这就是大O的渐进表示法（抓大头）。

1.2大O的渐进表示法：估算

大O符号：是用于描述函数渐进行为的数学符号
推导大O阶方法：

1. 用常数1取代运行时间中的所有加法常数
2. 在修改的运行次数函数中，只保留最高阶项
3. 如果最高阶项存在且不是1，则去除与这个项目相乘的常数，得到的结果就是大O阶
   大O阶的渐进表示去除了那些对结果影响不大的项，找影响最大的那个项，即，在实际中一般情况关注的是算法的最坏运行情况（预期管理法）。

1.3常见时间复杂度计算举例

1. 示例1：

// 计算Func2的时间复杂度？ 
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); 
}

2. 示例2：

// 计算Func3的时间复杂度？ 
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); 
}

3. 示例3：

// 计算Func4的时间复杂度？ 
void Func4(int N) 
{ 
	int count = 0; 
	for (int k = 0; k < 100; ++ k) 
	{ 
		++count; 
	} 
	printf("%d\n", count); 
}

4. 示例4：

// 计算strchr的时间复杂度？ 
const char * strchr ( const char * str, int character );

5. 示例5：

// 计算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; 
	}
}

6. 示例6：

// 计算BinarySearch的时间复杂度？ 
int BinarySearch(int* a, int n, int x) 
{ 
	assert(a); 
	int begin = 0; 
	int end = n-1; 
	// [begin, end]：begin和end是左闭右闭区间，因此有=号 
	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;
}

7. 示例7：

// 计算阶乘递归Fac的时间复杂度？ 
long long Fac(size_t N) 
{ 
	if(0 == N) 
		return 1; 
	return Fac(N-1)*N; 
}

8. 示例8：

// 计算斐波那契递归Fib的时间复杂度？ 
long long Fib(size_t N) 
{ 
	if(N < 3) 
		return 1; 
	return Fib(N-1) + Fib(N-2); 
}

计算结果及分析：

1. F(N) = 2N + 10 , 时间复杂度为O(N)【**以极限的角度考虑问题，系数都是要忽略的】
2. 不确定M和N的关系，那就带两个未知数，时间复杂度为O(M+N)或O(max(M,N))
   1. N远大于M—O(N)
   2. M远大于N—O(M)
   3. M和N差不多大—O(M) or O(N)
3. 执行了100次，但时间复杂度为O(1)【所有的常数都有1替代，O(1)代表的不是1次，而是常数次】
4. 对于strchr,本程序最好执行1次，最坏执行N次，时间复杂度是保守的估算一般取最坏为O(N)

while(*str)
{
	if(*str == character)
		return str;
	++str;
}

5. 两次循环一定是N^2吗，看下面这段代码

int PartSort1(int* a,int left,int right)
{
	//int midi = GetMidi(a,left,right);
	//Swap(&a[left],&a[midi]);

	int keyi = left;
	while(left < right)
	{
		//找小
		while(left < right && a[right] >= a[keyi])
		{
			--right;
		}

		//找大
		while(left < right && a[left] <= a[keyi])
		{
			++left;
		}

		Swap(&a[left],&a[right]);
	}
	Swap(&a[keyi],&a[left]);
}

我们先看示例5，示例5是冒泡排序：前一个大于后一个就要交换
则，F(N)=n*(n-1)/2，所以时间复杂度就是O(N^2)
再看上述代码，这是典型的快排思想的一部分，将比keyi大的放到右边，比它小的放到左边，直到两指针相遇停止，其时间复杂度就是O(N)。
由此可以发现，计算时间复杂度，我们不能数循环，更注重的是根据思想灵活计算
6. 第六题实际上是二分查找，二分查找的前提是有序

所以，时间复杂度为$O({\log }_{2}N)$(通常写O(logN)默认底数为2，只有2为底的都可以省略)
二分查找—暴力查找，时间复杂度很小（指数大爆炸）
7. 阶乘，
普通函数算的是一次调用，而阶乘算的是多次调用，多次调用是累加。时间复杂度看的是调用的次数，阶乘的结果才是乘起来的，我们要看的是次数，而不是结果
所以，本题是一个0-N的等差数列，时间复杂度为O(N^2)
8. 斐波那契数列
实际上是一个双动递归，就像细胞分裂一样，一生二，二生四……

用错位相减公式得F(N)=2^{(N-1)，所以时间复杂度为O(2}N)，用递归写斐波那契数列是一个实践意义很小的算法，指数大爆炸。用循环写斐波那契数列，可以得到优化，优化后时间复杂度为O(N)

---

2.空间复杂度

空间复杂度也是一个数学表达式，是对一个算法在运行过程中临时占用额外储存空间的量度，空间复杂度算的是对象，即变量的个数。
空间复杂度计算规则基本跟时间复杂度类似，也用大O渐进表示法，但是相对于时间复杂度来说，我们并不是很看重空间复杂度。
注意：函数运行时所需要的栈空间(存储参数、局部变量、一些寄存器信息等)在编译期间已经确定好了，因此空间复杂度主要通过函数在运行时候显式申请的额外空间来确定。

常见空间复杂度计算

1. 实例1：

// 计算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; 
	} 
}

2. 实例2：

// 计算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; 
}

3. 实例3：

// 计算阶乘递归Fac的空间复杂度？ 
long long Fac(size_t N) 
{ 
	if(N == 0) return 1; 
	return Fac(N-1)*N; 
}

计算结果及分析：

1. 冒泡排序的空间复杂度：O(1)，开辟的变量都是常数个，数组是本身的需要，而不是属于冒泡排序算法的需要
2. 根据的算法的需要，所开辟的空间，开辟了N个空间，所以空间复杂度为O(N)
3. 实例3递归调用了N次，开辟了N个栈帧，每个栈帧使用了常数个空间。空间复杂度为O(N)

---

3.复杂度oj练习

3.1消失的数字

oj链接：面试题 17.04. 消失的数字 - 力扣（LeetCode）

• 思路一：
  • 先冒泡排序
  • 遍历，当前值+1，不等于下一个数字就是下一个数
  • 时间复杂度：O(N^2)
• 思路二：
  • 使用[[不会知识点#^227a0d|异或]]
  • 初始化一个变量 x 为 0
  • 遍历数组中的每个元素，将它们也与 x 进行异或操作
  • 最终，x 将包含缺失的数字。
  • 详细分析见我的上一篇文章，其中还有对异或的详细分析：LeetCode练习：17.04消失的数字—异或的应用-CSDN博客
• 思路三：
  • 0-n等差数列公式计算和
  • 依次减掉数据中的值，剩下的就是消失的数字
  • 时间复杂度：O(N)

3.2轮转数组

oj链接：189. 轮转数组 - 力扣（LeetCode）

• 思路一：
  

  • 轮转三次，时间复杂度：O(N^2)
  • 最好情况：O(1),K是N的倍数时，不需要旋转
  • 最坏情况：K % N == N-1时O(N*(N-1)) -> O(N^2)

• 思路二：

  • 三步旋转法
  • 三步旋转法可以看作是找规律找出来的
  • 代码实现

void reverse(int* start, int* end) 
{  
    while (start < end) 
    {  
        int temp = *start;  
        *start = *end;  
        *end = temp;  
        start++;  
        end--;  
    }  
}  
  
void rotate(int* nums, int numsSize, int k) 
{  
    k = k % numsSize;  //防止k大于数组长度  
    reverse(nums, nums + numsSize - 1);  //反转整个数组  
    reverse(nums, nums + k - 1);         //反转前k个元素  
    reverse(nums + k, nums + numsSize - 1); //反转剩余的元素  
  
    //打印数组以验证结果  
    for (int j = 0; j < numsSize; j++) 
    {  
        printf("%d ", nums[j]);  
    }  
    printf("\n");  
}