1.算法效率
衡量一个算法的好坏，不一定单纯用简洁来判断，我们可以尝试用一个标准来衡定，这个标准叫：算法复杂度。
算法的复杂度
- 衡量算法的好坏，可以通过时间和空间两个维度一起来衡量
- 时间复杂度衡量一个算法的运行快慢
- 空间复杂度衡量一个算法运行所需要的额外空间
2.时间复杂度
- 算法的时间复杂度是一个函数，它本身从理论上无法算出来
- 但是我们能够知道的是：一个算法所花费的时间与其中语句的执行次数成正比例
- 算法中的基本操作的执行次数，即为算法的时间复杂度
我们来看看几个例子：
c
// 请计算一下Func1中++count语句总共执行了多少次？
void Func1(int N)
{
int count = 0;
for (int i = 0; i < N ; ++ i)
{
for (int j = 0; j < N ; ++ j)
{
++count;
}
} //N^2
for (int k = 0; k < 2 * N ; ++ k)
{
++count;
}//2N
int M = 10;
while (M--)
{
++count;
}//10
}- 下面是对应执行次数的函数：
- N = 10 - F(N)=130
- N = 100 - F(N)=10210
- N = 1000 - F(N) = 1002010
- 在实际计算中，我们不需要精确的计算执行次数，只需要大概的执行次数就可以，所以，我么可以通过大O渐进表示法来实现这个操作
大O渐进法
- 大O符号就是用于描述函数渐进行为的数学符号
- 大O阶的推导方法：
- 用常数1取代常数
- 修改后的运行次数函数中，只保留最高阶项
- 最高阶项存在且不为1，去除与高阶项相乘的常数，得到大O阶本身即可
- 那我们刚刚的FunC1的时间复杂度就是：O(N^2)
- 我们去掉了哪些对结果影响不大的项
- 算法的时间复杂度总存在不同的情况，但是在实际一般情况中关注的是算法的最坏运行情况
常见时间复杂度计算举例
c
// 计算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，因为最高阶项存在且不为1，去除与高阶项相乘的常数，得到大O阶本身即可(大O推导法3)
- 所以，其时间复杂度为O(N)
c
//计算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);
}- F(N) = M + N，但是要分情况看待
- 如果M>>N - 那结果就是O(M)
- 如果M<<N - 那结果就是O(N)
- 如果两者差不多大 - 那O(N)或者O(M)
- 如果无法确定 - 那结果就是O(N+M)
c
//计算Func4的时间复杂度？
void Func4(int N)
{
int count = 0;
for (int k = 0; k < 100; ++ k)
{
++count;
}
printf("%d\n", count);
}- F(N) = 100,此时得到的函数为一个常数
- 常数1用于取代运行时间中的所有加法常数
- 所以，函数的时间复杂度为O(1)
c
//计算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;
}
}- 冒泡函数对应的F(N)=(N-1)×(N-2)...2×1 = N×(N-1)/2
- 此时根据我们刚刚的规则：保留最高阶项并去掉绑定的常数
- 所以，它的时间复杂度为：O(N^2)
c
//计算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;
}
- 每一次的查找，都是查找到一个中间值，如果长度为N，每次找中间值查找，所以就不断除2，最后找到对应的那个值
- 图片中的公式解释了计算的过程
- 所以，最后的结果是：O(logN)
- 注意：但是注意，我们一般会把底数为2的log函数的2省略掉，便于书写和观看
- 但是如果底数不为2，那就要具体写出来
c
//计算阶乘递归Fac的时间复杂度？
long long Fac(size_t N)
{
if(0 == N)
return 1;
return Fac(N-1)*N;
}
- 递归次数不断累加，递归了N次
- 所以F(N)=N，时间复杂度也就是O(N)
c
//计算斐波那契递归Fib的时间复杂度？
long long Fib(size_t N)
{
if(N < 3)
return 1;
return Fib(N-1) + Fib(N-2);
}
- 通过图片可以知道，我们总共递归了2^N次，那么F(N) = 2的N次方
- 所以对应的时间复杂度就是O(2^N)
3.空间复杂度
- 空间复杂度，我们定义为：一个算法在运行过程中临时占用存储空间大小的量度
- 空间复杂度不用程序占用的空间来判断，而是通过变量的个数来算，也采用大O渐进表示法
- 函数运行时所需要的栈空间在编译期间已经确定好了，因此空间复杂度主要通过函数在运行时候显示申请的额外空间来确定
c
//计算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;
}
}- 函数里只用了常数个额外变量：end、i、exchange 等，数量不随 n 增长
- 交换 Swap(&a[i-1], &a[i]) 是原地交换（in-place），不需要开辟与 n 相关的额外数组
- 没有递归调用，因此也没有随 n 增长的递归栈空间。
- 所以，其空间复杂度为O(1)
c
// 计算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+1的long long类型的数组
- 所以，其空间复杂度为O(N)
c
// 计算阶乘递归Fac的空间复杂度？
long long Fac(size_t N)
{
if(N == 0)
return 1;
return Fac(N-1)*N;
}
- 这是递归实现，每次调用 Fac(N) 会再调用一次 Fac(N-1)，一直到 N==0
- 递归深度是 N+1 层（从 N 到 0）
- 根据图片我们也可以知道，有些栈帧空间会被反复利用，而不是说重复的开辟
- 总的来说：空间是峰值同时存在，而不是累计出现
- 先一路压栈：Fib(N) -> Fib(N-1) -> Fib(N-2) -> ... -> Fib(1/2)
- 到达基例后开始返回，再去算另一边分支。
- 不会把整棵递归树的所有节点同时放在栈里
- 每一层调用都会在调用栈上保存返回地址、参数、局部信息等，占用常数空间
- 所以，最后的空间复杂度为O(N)
4.常见复杂度对比
