【数据结构】算法复杂度

本文是小编巩固自身而作，如有错误，欢迎指出！

1.算法与算法效率 

1.1算法是什么

算法(Algorithm):就是定义良好的计算过程，他取⼀个或⼀组的值为输⼊，并产⽣出⼀个或⼀组值作为 输出。简单来说算法就是⼀系列的计算步骤，⽤来将输⼊数据转化成输出结果。

1.2算法效率

如何判断一个算法的好坏呢？其实就是通过算法的效率来判断，说简单一点就是看实现同一个效果所需要的时间长短，和占用的空间大小。这里就涉及到一个概念———复杂度。

1.2.1复杂度的概念

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

时间复杂度主要衡量⼀个算法的运⾏快慢，⽽空间复杂度主要衡量⼀个算法运⾏所需要的额外空间。 在计算机发展的早期，计算机的存储容量很⼩。所以对空间复杂度很是在乎。但是经过计算机⾏业的 迅速发展，计算机的存储容量已经达到了很⾼的程度。所以我们如今已经不需要再特别关注⼀个算法 的空间复杂度。

2.时间复杂度

定义：在计算机科学中，算法的时间复杂度是⼀个函数式T(N)，它定量描述了该算法的运⾏时间。

时 间复杂度是衡量程序的时间效率，那么为什么不去计算程序的运⾏时间呢？

1. 因为程序运⾏时间和编译环境和运⾏机器的配置都有关系，⽐如同⼀个算法程序，⽤⼀个⽼编译 器进⾏编译和新编译器编译，在同样机器下运⾏时间不同。

2. 同⼀个算法程序，⽤⼀个⽼低配置机器和新⾼配置机器，运⾏时间也不同。

3. 并且时间只能程序写好后测试，不能写程序前通过理论思想计算评估。

那算法复杂度的函数式T（N）到底是什么呢？，其实就是计算了程序的执行次数 

我们看看下面的代码，看看其操作次数

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; 
 } 
}

其中我们可以看到首先有一个大小为n次的for循环嵌套另一个n次的for循环 

即N^2.

再然后是一个2*N次的for循环，即2N.

最后是一个为M次即十次的whie循环

T(N）=N*2+2N+10

而其中当N趋近无线大时，影响最大的就是N^2，我们就认为其复杂度为O(N*2)

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

2.1大O的渐进表示法

表达规则

1. 时间复杂度函数式T(N)中，只保留最⾼阶项，去掉那些低阶项，因为当N不断变⼤时， 低阶项对结果影响越来越⼩，当N⽆穷⼤时，就可以忽略不计了。

2. 如果最⾼阶项存在且不是1，则去除这个项⽬的常数系数，因为当N不断变⼤，这个系数 对结果影响越来越⼩，当N⽆穷⼤时，就可以忽略不计了。

3. T(N)中如果没有N相关的项⽬，只有常数项，⽤常数1取代所有加法常数。

 我们看看以下例子

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

其中只有一层循环且数为已知数,其复杂度为O(1)

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

这个代码的作用是查找字符串的位置，那么就可能有以下情况

1.查找的字符串是第一个T(N)=1

2.查找的字符串是中间T(N)=N/2

3.查找的字符串是最后一个T(N)=N

但复杂度是去最差情况即复杂度是O（N）

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

1.若数组有序，则：T (N) = N

2.若数组有序且为降序，则：T (N) =   N ∗(N + 1)/2

3.若要查找的字符在字符串中间位置，

 因此：BubbleSort的时间复杂度取最 差情况为：O（N^2） 

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

当n=2时，执⾏次数为1

当n=4时，执⾏次数为2

 当n=16时，执⾏次数为4

假设执⾏次数为x ，则2 ^x=   n 因此执⾏次数：x = log n

 因此：func5的时间复杂度取最差情况为： O(log2 n)

注意课件中和书籍中log2 n 、log n 、lg n 的表示 当n接近⽆穷⼤时，底数的⼤⼩对结果影响不⼤。

因此，⼀般情况下不管底数是多少都可以省略不 写，即可以表⽰为log n 

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

 将递归函数调用了n次，复杂度就是n*函数的复杂度

O(N)

3.空间复杂度

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

 空间复杂度计算规则基本跟实践复杂度类似，也使⽤⼤O渐进表⽰法。

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

 我们看以下示例

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（N^2）,而其空间复杂度呢，因为其额外申请的空间有 exchange等有限个局部变量，使⽤了 常数个额外空间，所以其空间复杂度为O（1）

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

Fac递归调⽤了N次，额外开辟了N个函数栈帧， 每个栈帧使⽤了常数个空间 因此空间复杂度为：O(N)

今天关于复杂度的介绍就到这了，后续会继续更新，感谢阅读！