详细介绍：时间复杂度和空间复杂度

一、时间复杂度

1.定义

在计算机科学中，算法的时间复杂度是一个函数式T(N)，它定量描述了一个算法所需要的运行时间。

2.为何不计算程序运行时间？

(1)编译环境与设备的影响：同一个算法用老编译进行编译与用新编译器进行编译，在同一个机器下运行时间不同。同一个算法程序，用一个老底配置机器和新高配置机器，运行时间不同。
(2)时间只能程序写好后测试，不能再写程序之前通过理论思想计算评估。

3.函数式`T(N)`

T(N)函数式计算了程序的执⾏次数。我们知道算法程序被编译后⽣成⼆进制指令，程序运⾏，就是cpu执⾏这些编译好的指令,那么我们通过程序代码或者理论思想计算出程序的执⾏次数的函数式T(N)，假设每句指令执⾏时间基本⼀样(实际中有差别，但是微乎其微)，那么执⾏次数和运⾏时间就是等⽐正相关，这样也脱离了具体的编译运⾏环境。执⾏次数就可以代表程序时间效率的优劣。即：
程序执行的时间 = 二进制指令运行的时间(可以假定时间是一定的) * 执行次数

解决一个问题的算法a程序T(N)=N，算法b程序T(N)=N^2，显而易见算法a的效率一定优于算法b。

例如：

//计算Func1中++count语句一共执行了几次
void Func1(int N)
{
int count = 0;
for (int i = 0; i < N; ++i)   // 两个for循环嵌套--N^2次
{
for (int j = 0; j < N; ++j)
{
++count;
}
}
for (int k = 0; k < 2 * N; ++k) // 2N次
{
++count;
}
int M = 10;
while (M--)  // 10次
{
++count;
}
}

所以 Func1 执⾏的基本操作次数：

T (N) = N^2 + 2 ∗ N + 10

当N = 10 T(N) = 130
当N = 100 T(N) = 10210
当N = 1000 T(N) = 1002010

通过对N取值分析，我们可以知道对结果影响最大的一项是N^2

实际中计算时间复杂度时，计算的也不是程序的精确的执⾏次数，,因为不同的程序代码，编译出的指令条数是不⼀样的，计算出精确的执⾏次数意义不⼤，因为我们计算时间复杂度只是想⽐较算法程序的增⻓量级，也就是当N不断变⼤时T(N)的差别，上⾯我们已经看到了当N不断变⼤时常数和低阶项对结果的影响很⼩，所以我们只需要计算程序能代表增⻓量级的⼤概执⾏次数，复杂度的表⽰通常使⽤⼤O的渐进表⽰法

3.1大O的渐进表示法

大 O 符号( Big O natation )：是用于描述函数渐近行为的数学符号。

推导大O阶规则：

时间复杂度函数式T(N)中，只保留最⾼阶项，去掉低阶项，因为当N不断变⼤时，低阶项对结果影响越来越⼩，当N⽆穷⼤时，低阶项对结果的影响就可以忽略不计了。
例如：Func1 （T (N) = N^2 + 2 ∗ N + 10 ）它的时间复杂度为: O(N^2)
如果最⾼阶项存在且不是1，则去除这个项⽬的常数系数，因为当N不断变⼤，这个系数对结果影响越来越⼩，当N⽆穷⼤时，这个系数对结果的影响就可以忽略不计了。
例如：T (N) = N/2 它的时间复杂度为:O(N)
T(N)中如果没有N相关的项⽬，只有常数项，⽤常数1取代所有加法常数。
例如：T (N) = 10086它的时间复杂度为:O(1)

二、常见时间复杂度计算示例

（1）计算Func2的时间复杂度

void Func2(int N)
{
int count = 0;
for (int k = 0; k < 2 * N; ++k)  // 2N次
{
++count;
}
int M = 10;
while (M--)  //10次
{
++count;
}
printf("%d\n", count);
}

Func2执⾏的基本操作次数：
T (N) = 2N + 10
根据推导规则第1、2条得出
Func2的时间复杂度为： O(N)

（2）计算Func3的时间复杂度

void Func3(int N, int M)
{
int count = 0;
for (int k = 0; k < M; ++k) // M次
{
++count;
}
for (int k = 0; k < N; ++k) // N次
{
++count;
}
printf("%d\n", count);
}

Func3执⾏的基本操作次数：
T (N、M) = M + N
Func3的时间复杂度为：O(M+N)

我们还可以进一步推理(根据题目判断是否需要进一步推理)
这里我们需要对M和N进行讨论
(1) M >> N , Func3的时间复杂度为：O(M)
(2) M << N , Func3的时间复杂度为：O(N)
(3) M == N , Func3的时间复杂度为：O(M)/O(N)

（3）计算Func4的时间复杂度

void Func4(int N)
{
int count = 0;
for (int k = 0; k < 100; ++k) // 100次
{
++count;
}
printf("%d\n", count);
}

Func4执⾏的基本操作次数：
根据推导规则第3条得出
Func4的时间复杂度为： O(1)

（4）计算strchr的时间复杂度

const char* strchr(const char* str, int character)
{
const char* p_begin = s;
while (*p_begin != character)
{
if(*p_begin == '\0')
return NULL;
p_begin++;
}
return p_begin;
}

阅读代码我们可以知道这是一个在字符串里找字符的函数，假设这个字符串的长度为N，则有
(1) 若要查找的字符在字符串的第一个位置，有: T(N) = 1 则时间复杂度为： O(1)
(2) 若要查找的字符在字符串的最后的一个位置，有: T(N) = N 则时间复杂度为： O(N)
(3) 若要查找的字符在字符串的中间位置，有: T(N) = N/2 则时间复杂度为： O(N)

因此strchr的时间复杂度分为：
最好情况： O(1)
最坏情况： O(N)
平均情况： O(N)

总结：

有些算法的时间复杂度存在最好、平均和最坏情况。

最坏情况：任意输⼊规模的最⼤运⾏次数(上界)
平均情况：任意输⼊规模的期望运⾏次数
最好情况：任意输⼊规模的最⼩运⾏次数(下界)

⼤O的渐进表⽰法在实际中⼀般情况关注的是算法的上界，也就是最坏运⾏情况。

（5）计算BubbleSort的时间复杂度

void BubbleSort(int* a, int n)
{
assert(a);
for (size_t end = n; end > 0; --end)  // n次
{
int exchange = 0;
for (size_t i = 1; i < end; ++i)  // 内层循环为等差数列首项为n-1，末项为1
{
if (a[i - 1] > a[i])
{
Swap(&a[i - 1], &a[i]);
exchange = 1;
}
}
if(exchange == 0)
break;
}
}

分析如下

（n次）
外层循环   内层循环
第一次     n-1
第二次     n-2
第三次     n-3
...
第n-1次      2
第n次       1

根据上面的分析，可以知道BubbleSort执⾏的基本操作次数T(N)是等差数列求和
在这里插入图片描述
则T(N) = [(n-1)*(n-1+1)]/2 = (n^2)/2 + n/2 + 1/2
由推导大O阶规则第1，2，3条规则可得BubbleSort的时间复杂度为： `O(N^2)

（6）计算func5的时间复杂度

void func5(int n)
{
int cnt = 1;
while (cnt < n)
{
cnt *= 2;
}
}

仔细研究我们可以发现：

当 n = 2 时, 语句的执行次数为 1
当 n = 4 时, 语句的执行次数为 2
当 n = 8 时, 语句的执行次数为 3

假设执行次数为 x ，可以发现 n 与 x 的关系呈现 2^x = n，即 x = log n (下面会说为什么没有底数2)
因此func5的时间复杂度取最差情况为：O(log n)

为什么时间复杂度出现对数形式一般不写底数

根据换底公式：

其中分母是常数，在复杂度分析中，常数因子可忽略(根据大O阶规则第2条规则)
当n接近⽆穷⼤时，底数的⼤⼩对结果影响不⼤。因此，⼀般情况下不管底数是多少都可以省略不写，即可以表⽰为 log n
省略底数更简洁，且不影响复杂度的比较

（7）计算阶乘递归Fac的时间复杂度

long long Fac(size_t N)
{
if (0 == N)
return 1;
return Fac(N - 1) * N;
}

递归算法的时间复杂度 = 单次递归的时间复杂度 * 递归次数

可以观察到Fac函数是一个递归函数，进行分析：

第一次      第二次       第三次         第n-1次     第n次
Fac(N)--> Fac(N-1) --> Fac(N-2) .... Fac(1) --> Fac(0)
//到Fac(0)后函数开始返回，返回了n次

该函数单次递归的时间复杂度为：O(1) ,⽽在Fac函数中，存在n次递归调⽤Fac函数，因此阶乘递归的时间复杂度为： O(n)

三、空间复杂度

1. 定义

空间复杂度与时间复杂度一样，也是一个数学表达式，是对⼀个算法在运⾏过程中因为算法的需要额外临时开辟的空间。
空间复杂度不是程序占⽤了多少bytes的空间，因为常规情况每个对象⼤⼩差异不会很⼤，所以空间复杂度算的是变量的个数。
空间复杂度计算规则基本跟时间复杂度类似，也使⽤⼤O渐进表⽰法。

注意：函数运⾏时所需要的栈空间(存储参数、局部变量、⼀些寄存器信息等)在编译期间已经确定好了，因此空间复杂度主要通过函数在运⾏时候显式申请的额外空间来确定。

2. 示例

（1）计算BubbleSort的空间复杂度

void BubbleSort(int* a, int n) // a n是输入参数，用于传递原始数据，不属于额外变量
{
assert(a);
for (size_t end = n; end > 0; --end) // end 一个额外申请的变量
{
int exchange = 0; // exchange 一个额外申请的变量
for (size_t i = 1; i < end; ++i)  //  i 一个额外申请的变量
{
if (a[i - 1] > a[i])
{
Swap(&a[i - 1], &a[i]);
exchange = 1;
}
}
if(exchange == 0)
break;
}
}

一共有三个额外申请的变量，再根据大O阶规则的第3条定律，可得BubbleSort空间复杂度为 O(1)

（2）计算阶乘递归Fac的空间复杂度

long long Fac(size_t N)
{
if (N == 0)
return 1;
return Fac(N - 1) * N;
}