1. 算法效率
- 如何衡量一个算法的好坏?
- 一般是从时间和空间的维度来讨论复杂度,但是现在由于计算机行业发展迅速,所以现在并不怎么在乎空间复杂度了
- 下面例子中,斐波那契看上去很简洁,但是复杂度未必如此
long long Fib(int N){if(N < 3)return 1;return Fib(N-1) + Fib(N-2);}
- 摩尔定律,每两年硬件性能就会翻两倍,但是现在这个结论有些失效了,主要是因为计算机行业现在快处于瓶颈期了,很难再有突破
- 学习复杂度有什么用呢?
- 主要是在面试中和校招中考察。
- 其实再写一个算法的时候可以进行大概的估算
2. 时间复杂度
- 算法的时间复杂度是一个数学函数,定量描述了该算法的运行时间
- 每个机器的运行速度都不一样,不同的机器跑一样的代码,时间上会有差异
- 所以这个时候有了时间复杂度,时间复杂度计算的是程序执行的次数(大概的次数)
- 下面举个最简单的例子,下面代码的复杂度是多少?看时间复杂度,循环嵌套循环的复杂度就是 N^2
- 这个得出N^2,是因为在程序执行的时候,假设每执行100次,100次里的第一个循环就要执行100次,外层循环每次执行一次,里面的for循环就要执行100次。
int main()
{int n = 100000,count = 0;for (int i = 0; i < n; i++){for (int j = 0; j < n; j++){count++;}}printf("%d", count);return 0;
}
2.1. 大0的渐进表示法
- 看下面图来说,当 N 值越来越大的时候,2 * N + 10的部分影响就很小了
- 因为计算机运行的速度很快,比如我这个电脑运行速度是3.10GHz,也就意味着,在一段时间周期内可以处理3.1亿次指令,对于电脑来说多处理十几万的次数可谓相当轻松。
- 大O渐进法,就是对影响结果最大的值进行估算,只要保留最高项就行
- 再举个例子 1.N^2 + 2n; 2.N + 100; 3. N^3 。当N在10和100像这种比较小的数的时候,此时他们时间复杂度是差不多的。
2.2. clock 函数 <time.h>
- 返回程序消耗的处理器时间 ,单位 毫秒(ms)。
- 我的电脑,处理10亿次指令,用2075ms,2秒多。大家有兴趣,也可以用这个函数去试试
2.3. 例题
- 0 ms表示,运行时间小于1 ms
- 那么下面的时间复杂度是多少呢?时间复杂度计算的是大概的执行次数。是 F(N) = 2 * N + M; 用大O渐进法就是 O(N);
- 得出O(N),因为我们要省略对结果影响不大的值
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.3.1. 第二题
- 最好的情况就是一方远大于另一方
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);}
2.3.2. 第三题
- 那么这里是多少?,这个O(1), 这里意思不是执行1次,也不是执行时间低于1ms,而是这里的 1,表示常数次(常数就是1,2,3,4,5,...)
void Func4(int N){int count = 0;for (int k = 0; k < 100; ++ k){++count;}printf("%d\n", count);}
2.4. 大O符号(Big O notation):是用于描述函数渐进行为(大概)的数学符号
- 推导大O阶方法:
- 用常数1代替运行时的所有加法常数
- 去掉其他影响不大的项,只要保留最高阶项
- 如果最高阶项存在且不是1,则去除与这个项目相乘的常数。得到的结果就是大O阶。
- 本质:计算算法复杂度(次数) 属于哪个量级(level)
- 假如有两个富豪,一个有2000亿,另一个有3000亿,都去买咖啡喝,不管是便宜的200左右的,还是5000的,就算是50w的。富豪都买的起,意思想表达的就是富豪们都是属于一个级别的你买起,那么他也买的起,这点钱就无足轻重了
常见算法复杂度如下:
2.5. 复杂度的最好、平均和最坏
- 最坏情况:任意输入规模的最大运行次数(上限)
- 平均情况:输入任意数,期望的运行次数
- 最好情况:输入任意数,最小的运行次数(下限)
例如:在长度N的数组中查找一个数据
- 最好的情况 O(1),最坏的情况O(N),平均情况 N/2.
2.6. 例题,消失的数字
- 此题共提供两种思路
- 第1种:用按位或,先按位或上
- 第2种:所有项数相加,然后依次减去数组里的值,减去剩下来的值就是,单生狗
//方法1
int missingNumber(int* nums, int numsSize){int one = 0,second = 0;for(int i = 0;i <= numsSize;++i)//numsSize <= 多一个{one ^= i;}for(int j = 0;j < numsSize;j++){second ^= nums[j];}return one ^ second;
}
//方法2
int missingNumber(int* nums, int numsSize){int N = numsSize;//等差数列项数 resultint ret = (0 + N) * (N + 1) / 2; // N + 1 是因为确实的那个项for(int i = 0;i < numsSize; i++){ret -= nums[i];//ret 项数的总和,依次减去数组内的数}return ret;
}
- 图中是挨个异或,这里代码中直接先将0 - n,全部异或。然后再异或原数组,最有将两个异或,就得到了这个数
2.7. 轮转数组
- 循环条件是 left < right; //不用写 left <= right,当时单数的时候,交不交换都一样。,因为两边向中间靠拢交换
- 要画图,画清楚图代码都是水到渠成了
- 一定要注意,数组下标绝对不能是负数
void reverse(int* nums,int left, int right)
{while(left < right)//比较的下标值{int tmp = nums[left];nums[left] = nums[right];nums[right] = tmp;left++;right--;}
}
void rotate(int* nums, int numsSize, int k) {k %= numsSize;// k % numsSize 6 % 7 = 6reverse(nums,0,numsSize - k - 1);reverse(nums,numsSize - k,numsSize - 1);reverse(nums,0,numsSize - 1);
}
2.7.1. 还有一种方法,额外开辟空间
- 就是你们常说的用空间换时间,这个的空间复杂度是O(N),为什么是N,因为malloc开辟的空间是未知的
- 只要根据上面画的图,稍微推断一下就知道了
- 如果还不知道memcpy怎么使用的可以去看看 ,这篇博客C语言的内存函数
void rotate(int* nums, int numsSize, int k) {k %= numsSize;int* numsby = (int*)malloc(sizeof(int) * numsSize);//拷贝到新空间的前三个memcpy(numsby,nums + (numsSize - k),sizeof(int) * k);//把剩下的拷贝memcpy(numsby + k,nums,sizeof(int) * (numsSize - k));//把新空间的拷贝会numsmemcpy(nums,numsby,sizeof(int) * numsSize);free(numsby);numsby = NULL;
}
2.8. logN复杂度
int main()
{int n = 8;int count = 0, i = 1;for (i = 1; i < n; i *= 2){count++;}printf("%d\n", count);return 0;
}
- 二分查找的每次区间变化是 N / 2,每次查找都是N /2 /2 /2...
int main()
{int arr[] = { 1,2,3,4,5,6,7,8,9 };int sz = sizeof(arr) / sizeof(arr[0]);int left = 0, right = sz - 1;int k = 7;while (left <= right)//为啥有等于因为,为单数时还有一个数需要查找{int mid = left + (right - left) / 2;if (arr[mid] < k)//左半没有我需要的值left = mid + 1;else if (arr[mid] > k)//被查找的值小于中间值,此时说明右半区间没有需要的值right = mid - 1;else{printf("%d", mid);break;}left++;right--;}return 0;
}
2.9. 乘阶的复杂度
- 乘阶的复杂的是 N + 1,算的是函数的调用次数总和 ,所以就是O(N)。
// 计算阶乘递归Fac的时间复杂度?
long long Fac(size_t N){if(0 == N)return 1;return Fac(N-1)*N;}
- 如果乘阶里面还有计算呢?
long long Fac(size_t N){if(0 == N)return 1;for(int i; i < N;i++){;}return Fac(N-1)*N;}
- 这个时候每调用一次,for循环就会打印 N次,这个消耗也要算进去,而且这个是递归调用,每次调用自身都会打印 n - 1次的数据,直到满足结束条件。
- 所以在这个递归调用里,复杂度是 O(N^2);。所有递归次数累加
2.10. 斐波那契的复杂度
int Fib(int n)
{if (n < 3)return 1;return Fib(n - 1) + Fib(n - 2);
}int main()
{//斐波那契int ret = Fib(40);printf("%d ", ret);return 0;
}
- 对此上面的方法只有理论意义,并不具有实际意义
- 所以我们要用迭代的方法O(N),来解决,这个方法更好
int main()
{//斐波那契//迭代的方法,因为斐波那契前两项都是1unsigned long long x1 = 1;unsigned long long x2 = 1;unsigned long long x3 = 0;int n = 1150;for (int i = 3; i <= n; i++){x3 = x1 + x2;x1 = x2;x2 = x3;}printf("%lld", x3);return 0;
}
- 这种迭代的方法还是不够好,算较小的数还行,数字大了还是不行,会到类型上限
- 可以用字符串存储,只要空间够大,多大的数都能存储。不过还没学到,下次一定!!
3. 空间复杂度
- 一个算法重点关注时间复杂度,不太关注空间复杂度,除非是嵌入式那些有大小限制的设备上。
- 空间复杂度算的是变量的个数,因为每个变量的差异不大,为什么没有什么差异?,举个例子
- 1GB = 1024MB;1MB = 1024KB 1 KB = 1024 Byte ;1Byte = 8bit;
- 一个MB的空间都有这么大了,还在乎这么点空间吗?
- 空间复杂度使用的也是大O渐进法。
- 可以来看看实例 ,函数的形参部分的变量不算个数,算的是函数内额外的变量个数
- 在此题目中冒泡排序里面,发现只开辟了三个变量,空间复杂度是O(1)
void bbu(int a[], int len)
{for (int i = 0; i < len - 1; i++){for (int j = 0; j < len - i - 1; j++){if (a[j] < a[j + 1]){int tmp = a[j];a[j] = a[j + 1];a[j + 1] = tmp;}}}
}
3.1. 空间复杂度 O(N)
- 实际上空间复杂度比时间复杂度更加容易计算
- 常见的空间复杂度只有三个,O(1) O(N) O(N^2);但是也有其他的
- 举个空间复杂为O(N)的例子
- 每次函数的调用都会创建一个栈帧,创建了多少个栈帧就是多大的空间,会调用N次,O(N)了
// 计算阶乘递归Fac的空间复杂度?
long long Fac(size_t N)
{if(N == 0)return 1;return Fac(N-1)*N;
}
总结:个人觉得可能会不太详细,但是重点部分都没拉下