如何判断一个程序算法的好坏
例如：
如何判断下面的求斐波那契数列的算法好还是不好
public static long Fib(int N){
if(N < 3){
return 1;
}
return Fib(N-1) + Fib(N-2);
}
- 判断一个程序的好坏可以从
算法的效率上判断
算法效率
首先我们先了解什么是算法，算法（Algorithm）是指用来操作数据、解决程序中的问题的方法
假设如果我们有一个工作上的问题，用不同的算法去解决，结果可能是一样的，但是中间消耗的时间和空间一定是不一样的
算法分析有二种：
- 第一种是
时间的效率 - 第二种是
空间的效率
时间的效率被称为时间复杂度，而空间效率被称作空间复杂度
时间复杂度主要衡量的是一个算法的运行速度，而空间复杂度主要衡量一个算法所需要的额外空间
时间复杂度
时间复杂度是指程序要运算多少次，这个算法所需要的计算工作量
时间复杂度是计算程序算法的执行次数，计算时间的复杂度并不是计算精确的次数，而是估算
在编写程序前，依据统计方法对算法进行估算（大概的运行次数）
- 一个程序在计算机上运行时所消耗的时间取决于下列因素：
- 算法采用的策略方法
- 编译产生的代码质量
- 问题的输入规模
- 机器执行指令的速度
计算常见的时间复杂度
例如：
请计算一下Fun执行了几次呢？
void Fun(int n)
{
int count = 0;
for (int i = 0; i < n; i++)// count在这里执行了N*N次。
{
for (int j = 0; j < n; j++)
{
count++;
}
}
for (int i = 0; i < 2 * n; i++)//在这里执行了2*N次。
{
count++;
}
for (int i = 0; i < 10; i++)//在这里执行了10次。
{
count++;
}
}
上面程序准确的执行次数是：N²+2N+10次
在这里我们只统计了主要的执行次数。然而时间复杂度其实是一种估算
是由影响时间复杂度最大项决定的，在这里影响最大的项为N²
Fun执行的次数：
| N的值 | N²的值 | 计算的次数 |
|---|---|---|
| 10 | 100 | 130 |
| 100 | 10000 | 10210 |
| 1000 | 1000000 | 1002010 |
随N值的增大，这个表达式 N²对结果的影响是最大的
时间复杂度是估算，是看表达式中影响最大的那一项
计算时间复杂度时，其实并不一定要计算精确的次数，而只需要大概的执行次数，计算大概的次数是使用大O的渐进法
大O的渐进法
- 用常数1代替式中所有常数。
- 在修改过的式子中保留最高阶。
- 若最高阶为常数结果就是1。
- 若最高阶不是常数的话结果就是这个最高阶
时间复杂度的练习题
例题1：
计算Fun的时间复杂度
void Fun(int N)
{
int count = 0;
for (int K = 0; K < 2 * N; K++)//执行2N次
{
count++;
}
int M = 0;
for (M = 10; M > 0; M--)//执行10次
{
count++;
}
printf("%d\n", count);
}
准确的次数：2 * N + 10次
但是用大O渐进法是如果是常数（不可改变的整数），可以省略
答案是：O(N)
O（）表示是估算
例题2 ：
计算Fun2的时间复杂度
void Fun2(int N, int M)
{
int count = 0;
for (int k = 0; k < N; k++) 执行次数为N
{
const++;
}
for (int k = 0; k < M; k++) 执行次数为M
{
const++;
}
}
N 和 M 都是未知数，估算的次数是 N+M
注意：时间复杂度里不可能只有一个未知数，有可能有多个未知数
答案：O(N+M)
假设：如果题中说M远远大于N，那么答案就是：O(M)
例题3：
计算 Fun3 的时间复杂度
void Fun3(int N) 这里的N对我们的时间复杂度没有影响
{
int count = 0;
for (int k = 0; k < 100; k++) 在此处执行了100次
{
count++;
}
printf("%d\n", count);
}
所以不可改变的整数，都是用 常数 1 来代替
答案：O(1)
例题4：
计算 strch 的时间复杂度
const char* strch(const char* str, char rac)
{
while (*str != '\0') 这里在 str 的字符串里找 rac 字符
{
if (*str == rac)
{
return str;
}
str++;
}
return NULL;
}
- 有些算法的时间复杂度是不固定的，存在最好、平均和最坏的情况
最坏情况：操作执行的最大次数（上限）
平均情况：操作执行的期望运行次数
最好情况：操作执行的最小次数 - 例如：在长度为N的字符串，找字符‘a’
最好的情况：1次找到
平均的情况：N/2次找到
最坏的情况：N次找到
这种情况下是以最坏的情况
答案是：O(N)
例题5：
计算这个冒泡排序的时间复杂度
void bubble(int* str,int sz)
{
int i = 0;
for (i = 0; i < sz-1; i++)
{
int j = 0;
for (j = 0; j < sz - 1 - i; j++)
{
if (str[j] > str[j + 1])
{
int tmp = str[j];
str[j] = str[j + 1];
str[j + 1] = tmp;
}
}
}
}
看下面动态图，方便理解冒泡排序
第一趟冒泡：N次
第二趟冒泡：N-1次
第三趟冒泡：N-2次
…
第N趟：1次
准确的次数是：（N+1）*N/2
答案：O（N²）
例题6：
这个例子是二分查找
计算Fun6的时间复杂度
int Binary(int* a, int n, int x)
{
int left = 0;
int right = n;
while (left < right)
{
int mid = left + (right - left) / 2;
if (a[mid] < x)
left = mid + 1;
else if (a[mid] > x)
right = mid;
else
return mid;
}
return -1;
}
假设找了X次
1*.2*.2*.2…*2 = N
2^x = N
x = logN
logN 是二分之一的 N 次数
答案是：O(logN)
例题7：
计算Fun7的时间复杂度
计算阶乘的递归
long long Fac(int N)
{
return N < 2 ？ N : Fun(n-1)*N;
}
它递归了N次，每次递归运算 O（1）
整体就是:O(N)
时间的复杂度对比
常见的时间复杂度：
O(N^2)、O(N)、O(logN)、O(1)
空间复杂度
空间复杂度是对一个算法在运行中临时占用空间的储存大小的量度
空间复杂度不是计算程序占用了多少个字节的空间，没有意义
空间复杂度是计算的是变量的个数，空间复杂度计算的规则是和时间复杂度类似，也是使用大O的渐进法
// 计算bubbleSort的空间复杂度？
void bubbleSort(int[] array) {
for (int end = array.length; end > 0; end--) {
boolean sorted = true;
for (int i = 1; i < end; i++) {
if (array[i - 1] > array[i]) {
Swap(array, i - 1, i);
sorted = false;
}
}
if (sorted == true) {
break;
}
答案：O(1)
例题2：
// 计算fibonacci的空间复杂度？
int[] fibonacci(int n) {
long[] fibArray = new 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)
例题3：
// 计算阶乘递归Factorial的空间复杂度？
long factorial(int N) {
return N < 2 ? N : factorial(N-1)*N;
}
答案：O(N)
总结
-
时间复杂度
时间复杂度是计算一个程序的执行次数，结果不需要特别的准确，大多都是估算 -
空间复杂度
空间复杂度是计算程序的临时的变量，计算的是最多时使用临时的变量是多少 -
大O的渐进法
对于程序中所有常数(不可以改变的整数)都用常数1来表示
1290
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
