时间复杂度和空间复杂度详解

为什么会有时间和空间复杂度

我们评估一个算法的好坏，就是看他的效率，而他的效率的度量就是时间和空间复杂度
比较规则***O(1)<O(logN)<O(n)<o(n^2)<O(n!)*** //常对幂指阶
因为时间复杂度和空间复杂度都是估算，所有我们一般只用看那最深沉内循环的语句

时间复杂度

算法中所有语句的频度之和----就是时间复杂度，他是累计的
若一个算法的时间复杂度为O（n），则表明他的执行时间和n成正比
而n的系数都是可以忽略的
看看例子
样例1，我们该如何分析呢？

//我们要计算的是最深处语句的频度
//设执行了a次 ，如果跳出循环的化， 那么2^a=n ----->a=logN 则该算法的时间复杂度为logN
void fun(int n)
{
	int i = 1;
	while (i <= n)
	{
		i = i * 2;
	}
}

样例2

//假设执行了a次，跳出循环要满足2^a=n/2------>>也就是a+1=logN
//时间复杂度也就是O(logN)
x = 2
while (x < n / 2)
	x = 2 * x;

样例3

//显然执行了n次，所以时间复杂度O（n)
int fact(int n)
{
	if (n <= 1)
		return 1;
	else
		return n * fact(n - 1);
}

样例4
已知两个长度分别为m和n的升序链表，若将他们合并为长度m+n的一个降序链表，则
最坏的时间复杂度是多少？

样例5

//两层的循环变量没什么关系，直接算出两层各自的时间复杂度相乘即可
//外层显然是logN
//内层是n
//所以是O（nlogN）
count = 0;
for (k = 1; k <= n; k *= 2)
for (j = 1; j <= n; j++)
count++;

样例6

//这里要注意一下 前置++i，i的值是一直在发生变化的
//i的值是1，2，3，4，5，6，，，，，，
//假设执行了a次停止，则1+2+3+，，，+a=n
//所以是（1+a）*a/2=n----->>就是a=n^(1/2)  即时间复杂度是O（n的二分之一次方）
int func(int n)
{
	int i = 0, sum = 0;
	while (sum < n)
		sum += ++i;
	return i;
}

样例7

//这里i的值仍旧在发生变化1,2,3,,,,,,
//假设执行了a次，那就是a*a*a>n ---->所以时间复杂度是n^(1/3)
void fun(int n)
{
	int i = 0;
	while (i * i * i <= n)
		i++;
}

样例8

//外层和内层的循环变量有联系，所以要注意一下
//i=n-1时，执行n-1次， i=n-2时 执行n-2次，，，，，i=1时，执行一次
//相加就是1+2+3，，，，+（n-1）次  就是n*(n-1)/2  也就是O（n^2）
for(i = n - 1; i > 1; i--)
 for(j=1; j<i; j++)
	if(A[j]>A[j+1])
	  A[j]与[j+1]对换

样例9
//循环变量之间有联系，所以要细节分析
// i=1,执行2次，i=2执行4次，，，，，，i=n，执行2n次
加起来执行次数也就是（1+n）*n ------>O(n^2)

int m = 0, i, j;
for (i = 1; i <= n; i++)
for (j = 1; j <= 2 * i; j++) 
            m++;

空间复杂度

空间复杂度就是-----临时占用存储空间大小的量度
如果以一个算法的空间复杂度为O（1），那么指算法所需的辅助空间为常量

样例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;
}

定义了3个变量，所以为O（1），空间不是累计的，如果进行下一次循环，上一次的循环变量值就销毁了

样例2

//这个题一定要注意一下 是O(n)
int fib(int n)
{
	if (n <= 2)
		return 1;
	else
		return fib(n - 1) + fib(n - 2);
}

看看下面的理解一下