目录

算法效率

如何衡量一个算法的好坏

算法的复杂度

时间复杂度

时间复杂度的概念

大O的渐进表示法  

常见时间复杂度计算举例                

例一：                                            

例二：

例三：

例四： 

 例五：

 例六：  

 例七： 

 例八： 

空间复杂度

 例一： 

 例二： 

 例三： 

常见复杂度对比 

复杂度的oj练习 

好题分享

算法效率

如何衡量一个算法的好坏

        通过算法的时间复杂度和空间复杂度！

算法的复杂度

        算法在编写成可执行程序后，运行时需要耗费时间资源和空间(内存)资源 。因此衡量一个算法的好坏，一般是从时间和空间两个维度来衡量的，即时间复杂度和空间复杂度。

时间复杂度

时间复杂度的概念

        找到某条基本语句与问题规模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;
}
printf("%d\n", count);
}

        第一段执行n*n次

        第二段执行2*n次

        第三段执行10次

准确的实间复杂度函数式是：

大O的渐进表示法  

使用大O的渐进表示法以后，Func1的时间复杂度为：

O(n） 

        随着n越大，后两项对结构影响几乎可以忽略不计！

        通过上面我们会发现大O的渐进表示法去掉了那些对结果影响不大的项，简洁明了的表示出了执行次数。    

• 最坏情况：任意输入规模的最大运行次数(上界)
• 平均情况：任意输入规模的期望运行次数
• 最好情况：任意输入规模的最小运行次数(下界)

• 最好情况：1次找到
• 最坏情况：N次找到
• 平均情况：N/2次找到

常见时间复杂度计算举例                

例一：                                            

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

        实际：F(N) = 2*N+10  

        基本操作执行了2N+10次，通过推导大O阶方法知道，时间复杂度为 O(N)

例二：

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

        基本操作执行了M+N次，有两个未知数M和N，时间复杂度为 O(N+M)

ps:

• 不知道M和N的大小        O（N+M)
• N远大于M                      O（N）
• M远大于N                      O（M）
• M和N差不多                  O（M）或 O（N）

例三：

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

例四： 

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

        这个函数是查找一个字符！

内部实现为：

while（*str）
{if(*str == character)return str;else++str
}
return NULL;

 例五：

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

 例六：  

// 计算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;elsereturn mid;}return -1;
}

 例七： 

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

         通过计算分析发现基本操作递归了N次，时间复杂度为O(N)

 例八： 

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

空间复杂度

 例一： 

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

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

 例二： 

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

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

 例三： 

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

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

常见复杂度对比 

复杂度的oj练习 

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

int missingNumber(int* nums, int numsSize){int x = 0;for(int i = 0;i < numsSize;++i){x ^= nums[i];        }for(int j = 0;j < numsSize+1;++j){x ^=j;}return x;
}

189. 轮转数组 - 力扣（LeetCode）

void reverse(int* a, int left, int right)
{while(left < right){int tmp = a[left];a[left] = a[right];a[right] = tmp;++left;--right;}
}void rotate(int* nums, int numsSize, int k){k = k % numsSize;reverse(nums,numsSize - k, numsSize - 1);reverse(nums,0, numsSize - k - 1);reverse(nums, 0, numsSize - 1);
}

好题分享

1.下列有关大O表示法的说法错误的是

        A.大O表示法只是对程序执行时间的一个估算

        B.大O表示法只保留最高阶项

        C.大O表示法会保留一个系数来更准确的表示复杂度

        D.大O表示法一般表示的是算法最差的运行时间

 答案解析：

答案：C

解析：大O是一个渐进表示法，不会去表示精确的次数，cpu的运算速度很快，估计精确的没有意义。

2. 分析以下程序的时间复杂度

for(int i=0;i

void fun(int n) {int i=l;while(i<=n)i=i*2;
}

 int f ( unsigned int n ) {if (n == 0 || n==1) return 1;else return n * f(n-1);}