文章目录
算法的复杂度
1、时间复杂度
定义：在计算机科学中，算法的时间复杂度是⼀个函数式T(N)，它定量描述了该算法的运行时间。
++这个T(N)函数式计算了程序的执行次数，执行次数就可以代表程序时间效率的优劣。比如解决⼀个问题的算法a程序T(N) = N，算法b程序T(N) = N^2，那么算法a的效率⼀定优于算法b。++
以下面程序为例子：
c
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;
}
}Func1 执行的基本操作次数：
T (N) = N2 + 2 ∗ N + 10
- N = 10 T (N) = 130
- N = 100 T (N) = 10210
- N = 1000 T(N) = 1002010
通过对N取值分析，对结果影响最大的⼀项是 N^2^。易知当N不断变大时常数和低阶项对结果的影响很小，所以我们只需要计算程序能代表增长量级的大概执行次数，复杂度的表示通常使用大O的渐进表示法。
1.1大O的渐进表示法
1.1.1推导规则
- 时间复杂度函数式T(N)，只保留最高阶项，去掉低阶项，因为当N不断变大时，低阶项对结果的影响越来越小，当N无穷大的时候，就可以忽略不计了
- 如果最高阶项存在且不是1，则去除这个项目的常数系数，因为当N不断变大，这个系数对结果的影响也越来越小，当N无穷大时可忽略不计
- T(N)中如果没有N相关的项目，只有常数项，用常数1取代所有加法常数
通过以上规则可以得出上文中的代码的时间复杂度时：O(N^2^)
1.1.2计算演示
示例1：
c
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);
}T (N) = 2N + 10 ，因此时间复杂度为O(N)
示例2：
c
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);
}T(N)=M + N，因此时间复杂度为：O(N)
示例3：
c
void Func4(int N)
{
int count = 0;
for (int k = 0; k < 100; ++ k)
{
++count;
}
printf("%d\n", count);
}T (N) = 100，因此时间复杂度为： O(1)
示例4：
c
char * strchr ( char* str, int character)
{
char* p_begin = s;
while (*p_begin != character)
{
if (*p_begin == '\0')
return NULL;
p_begin++;
}
return p_begin;
}这个函数需要分情况来讨论：
（1）若查找的字符在字符串的第一个位置，则T(N)=1；
（2）若查找的字符在字符串的最后一个位置，则T(N)=N；
（3）若查找的字符在字符串中间位置，则T(N)= N 2 \frac{N}{2} 2N；
因此，strchr函数的时间复杂度有以下几种情况：
- 最好情况：O(1)
- 最坏情况：O(N)
- 平均情况：O(N)
示例5： 计算冒泡排序的时间复杂度
c
void BubbleSort(int* a, int n)
{
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;
}
}同样，对于数组的杂乱程度，我们也应该分情况考虑。
（1）若数组有序，则T(N)=N （这里注意，由于当数组本来就是排好序的，所以第二层的for循环就只用循环一遍，所以执行的次数应该仍然是N而不是N^2^）
（2）若数组有序且为降序，则T(N)= N ∗ ( N + 1 ) 2 \frac{N*(N+1)}{2} 2N∗(N+1)
因此：BubbleSort的时间复杂度取最差情况为： O(N^2^)
示例6
c
void func5(int n)
{
int a = 1;
while (a < n)
{
a *= 2;
}
}假设执行次数为x，则2^x^=n
所以执行次数为：x= log n
因此func5函数的时间复杂度取最差情况为O(log~2~n)
注：当n接近无穷⼤时，底数的大小对结果影响不大。因此，一般情况下不管底数是多少都可以省略不 写，即可以表示为 log n
示例7
c
long long func6(size_t N){
if(N == 0)
return 1;
return func6(N-1)*N;
}//阶乘调用一次func6函数的时间复杂度为O(1)，在这个程序中，存在n次递归调用func6函数
因此阶乘递归的时间复杂度为： O(N)
2、空间复杂度
空间复杂度也是⼀个数学表达式，是一个算法在运行过程中因为算法的需要额外临时开辟的空间。空间复杂度算的是变量的个数，也是用大O渐进表示法
2.1计算演示
示例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;
}
}函数栈帧已经在编译期间确定好了，著需要关注函数在运行时额外申请的空间
上述代码示例中申请了exchange局部变量，使用常数个额外空间
因此空间复杂度为O(1)
示例2
c
long long func(size_t N)
{
if(N == 0)
return 1;
return func(N-1)*N;
}func递归调用了N次，额外开辟了N个函数栈帧， 每个栈帧使用了常数个空间
因此空间复杂度为： O(N)
函数栈帧已经在编译期间确定好了，著需要关注函数在运行时额外申请的空间
上述代码示例中申请了exchange局部变量，使用常数个额外空间
因此空间复杂度为O(1)
示例2
c
long long func(size_t N)
{
if(N == 0)
return 1;
return func(N-1)*N;
}func递归调用了N次，额外开辟了N个函数栈帧， 每个栈帧使用了常数个空间
因此空间复杂度为： O(N)