【数据结构(六)】排序算法介绍和算法的复杂度计算（1）

文章目录

[1. 排序算法的介绍](#1. 排序算法的介绍)
- [1.1. 排序的分类](#1.1. 排序的分类)
[2. 算法的时间复杂度](#2. 算法的时间复杂度)
- [2.1. 度量一个程序(算法)执行时间的两种方法](#2.1. 度量一个程序(算法)执行时间的两种方法)
- [2.2. 时间频度](#2.2. 时间频度)
- - [2.2.1. 忽略常数项](#2.2.1. 忽略常数项)
  - [2.2.2. 忽略低次项](#2.2.2. 忽略低次项)
  - [2.2.2. 忽略系数](#2.2.2. 忽略系数)
- [2.3. 时间复杂度](#2.3. 时间复杂度)
- [2.4. 常见的时间复杂度](#2.4. 常见的时间复杂度)
- [2.5. 平均时间复杂度和最坏时间复杂度](#2.5. 平均时间复杂度和最坏时间复杂度)
[3. 算法的空间复杂度](#3. 算法的空间复杂度)

1. 排序算法的介绍

排序也称排序算法(Sort Algorithm)，排序是将一组数据，依指定的顺序进行排列的过程。

1.1. 排序的分类

内部排序:
指将需要处理的所有数据都加载到**内部存储器(内存)**中进行排序。
外部排序法：
数据量过大，无法全部加载到内存中，需要借助**外部存储(文件等)**进行排序。

常见的排序算法分类(见下图):

2. 算法的时间复杂度

2.1. 度量一个程序(算法)执行时间的两种方法

事后统计的方法

这种方法可行, 但是有两个问题：

一是要想对设计的算法的运行性能进行评测，需要实际运行该程序；

二是所得时间的统计量依赖于计算机的硬件、软件等环境因素, 这种方式，要在同一台计算机的相同状态下运行，才能比较那个算法速度更快。
事前估算的方法

通过分析某个算法的时间复杂度来判断哪个算法更优。

2.2. 时间频度

基本介绍：

时间频度：一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。一个算法中的语句执行次数称为语句频度或时间频度。记为 T ( n ) T(n) T(n)。

举例说明-基本案例

比如计算 1-100 所有数字之和, 可设计两种算法：

2.2.1. 忽略常数项

结论:

① 2 n + 20 2n+20 2n+20 和 2 n 2n 2n 随着 n n n 变大，执行曲线无限接近， 20 20 20 可以忽略

② 3 n + 10 3n+10 3n+10 和 3 n 3n 3n 随着 n n n 变大，执行曲线无限接近， 10 10 10 可以忽略

2.2.2. 忽略低次项

结论:

① 2 n 2 + 3 n + 10 2n^2+3n+10 2n2+3n+10 和 2 n 2 2n^2 2n2 ，随着 n n n 变大，执行曲线无限接近, 可以忽略 3 n + 10 3n+10 3n+10

② n 2 + 5 n + 20 n^2+5n+20 n2+5n+20 和 n 2 n^2 n2 ，随着 n n n 变大，执行曲线无限接近, 可以忽略 5 n + 20 5n+20 5n+20

2.2.2. 忽略系数

结论:

① 随着 n n n 值变大， 5 n 2 + 7 n 5n^2+7n 5n2+7n 和 3 n 2 + 2 n 3n^2 + 2n 3n2+2n ，执行曲线重合, 说明这种情况下, 5 5 5 和 3 3 3 可以忽略。

② 而 n 3 + 5 n n^3+5n n3+5n 和 6 n 3 + 4 n 6n^3+4n 6n3+4n ，执行曲线分离，说明多少次方是关键

2.3. 时间复杂度

一般情况下，算法中的基本操作语句的重复执行次数 是问题规模 n n n 的某个函数，用 T ( n ) T(n) T(n)表示，若有某个辅助函数 f ( n ) f(n) f(n)，使得当 n n n 趋近于无穷大时， T ( n ) f ( n ) \frac {T(n)}{f(n)} f(n)T(n) 的极限值为不等于零的常数 ，则称 f ( n ) f(n) f(n)是 T ( n ) T(n) T(n)的同数量级函数。记作 T ( n ) = Ｏ ( f ( n ) ) \pmb{T(n)=Ｏ( f(n) )} T(n)=Ｏ(f(n))，称Ｏ ( f ( n ) ) Ｏ( f(n) ) Ｏ(f(n)) 为算法的渐进时间复杂度，简称时间复杂度 。

T ( n ) T(n) T(n) 不同，但时间复杂度可能相同。如： T ( n ) = n 2 + 7 n + 6 T(n)=n^2+7n+6 T(n)=n2+7n+6 与 T ( n ) = 3 n 2 + 2 n + 2 T(n)=3n^2+2n+2 T(n)=3n2+2n+2 它们的 T ( n ) T(n) T(n) 不同，但时间复杂度相同，都为 O ( n 2 ) \pmb{O(n²)} O(n2)。

计算时间复杂度的方法：

（以 T ( n ) = n 2 + 7 n + 6 T(n)=n^2+7n+6 T(n)=n2+7n+6 为例）

①用常数 1 1 1 代替运行时间中的所有加法常数。

T ( n ) = n 2 + 7 n + 6 T(n)=n^2+7n+6 T(n)=n2+7n+6 --> T ( n ) = n 2 + 7 n + 1 T(n)=n^2+7n+1 T(n)=n2+7n+1

②修改后的运行次数函数中，只保留最高阶项。

T ( n ) = n 2 + 7 n + 1 T(n)=n^2+7n+1 T(n)=n2+7n+1 --> T ( n ) = n 2 T(n) = n^2 T(n)=n2

③去除最高阶项的系数。

T ( n ) = n 2 T(n) = n^2 T(n)=n2 --> T ( n ) = n 2 T(n) = n^2 T(n)=n2 --> O ( n 2 ) O(n^2) O(n2)

2.4. 常见的时间复杂度

常数阶 O ( 1 ) O(1) O(1)
对数阶 O ( l o g 2 n ) O(log_2n) O(log2n)（其中， l o g log log以2为底，也可以是以3、4、5......为底）
线性阶 O ( n ) O(n) O(n)
线性对数阶 O ( n l o g 2 n ) O(nlog_2n) O(nlog2n)（其中， l o g log log以2为底，也可以是以3、4、5......为底）
平方阶 O ( n 2 ) O(n^2) O(n2)
立方阶 O ( n 3 ) O(n^3) O(n3)
k 次方阶 O ( n k ) O(n^k) O(nk)
指数阶 O ( 2 n ) O(2^n) O(2n)

常见的时间复杂度对应的图：

说明：

常见的算法时间复杂度由小到大依次为： O ( 1 ) Ο(1) O(1)＜ O ( l o g 2 n ) Ο(log_2n) O(log2n)＜ O ( n ) Ο(n) O(n)＜ O ( n l o g 2 n Ο(nlog_2n O(nlog2n)＜ O ( n 2 ) Ο(n^2) O(n2)＜ O ( n 3 ) Ο(n^3) O(n3)＜ O ( n k ) Ο(n^k) O(nk) ＜ O ( 2 n ) Ο(2^n) O(2n) ，随着问题规模 n 的不断增大，上述时间复杂度不断增大，算法的执行效率越低。

从图中可见，我们应该尽可能避免使用指数阶的算法。

① 常数阶 O ( 1 ) O(1) O(1)

无论代码执行了多少行，只要是没有循环等复杂结构，那这个代码的时间复杂度就都是 O ( 1 ) O(1) O(1)

java 复制代码

int i = 1;
int j =2;
++i;
j++;
int m = i + j;

上述代码在执行的时候，它消耗的时候并不随着某个变量的增长而增长，那么无论这类代码有多长，即使有几万几十万行，都可以用O(1)来表示它的时间复杂度。

② 对数阶 O ( l o g 2 n ) O(log_2n) O(log2n)

java 复制代码

int i =1;
while(i < n){
	i= i * 2;
}

说明：

在while循环里面，每次都将 i i i 乘以 2 2 2，乘完之后， i i i 距离 n n n 就越来越近了。假设循环 x x x 次之后， i i i 就大于 n n n 了，此时这个循环就退出了，也就是说 2 2 2 的 x x x 次方等于 n n n，那么 x = l o g 2 n x=log_2n x=log2n也就是说当循环 l o g 2 n log_2n log2n 次以后，这个代码就结束了。因此这个代码的时间复杂度为： O ( l o g 2 n ) O(log_2n) O(log2n) 。

O ( l o g 2 n ) O(log_2n) O(log2n) 中的2是根据代码变化的，若 i = i ∗ 3 i = i * 3 i=i∗3 ，则是 O ( l o g 3 n ) O(log_3n) O(log3n)。

如果 N = a x ( a > 0 , a ≠ 1 ) N= a^x(a > 0,a ≠1) N=ax(a>0,a=1)，即 a a a 的 x x x 次方等于 N ( a > 0 , a ≠ 1 ) N(a>0,a≠1) N(a>0,a=1)，那么数 x x x 叫做以 a a a 为底 N N N 的对数 ( l o g a r i t h m ) (logarithm) (logarithm)，记作 x = l o g a N x = log_aN x=logaN 。其中， a a a 叫做对数的底数， N N N 叫做真数， x x x 叫做 "以 a a a 为底 N N N 的对数" 。

③ 线性阶 O ( n ) O(n) O(n)

java 复制代码

for(i = 1; i <= n; ++i){
	j = i;
	j++;
}

说明：

这段代码，for循环 里面的代码会执行 n n n 遍，因此它消耗的时间是随着 n n n 的变化而变化的，因此这类代码都可以用 O ( n ) O(n) O(n) 来表示它的时间复杂度。 T ( n ) = n + 1 T(n)=n+1 T(n)=n+1 --> O ( n ) O(n) O(n)

④ 线性对数阶 O ( n l o g 2 n ) O(nlog_2n) O(nlog2n)

java 复制代码

for(m = 1; m < n; m++){
	i = 1;
	while(i < n){
		i = i * 2;
	}
}

说明：

线性对数阶 O ( n l o g 2 N ) O(nlog_2N) O(nlog2N) 其实非常容易理解，将时间复杂度为 O ( l o g 2 n ) O(log_2n) O(log2n) 的代码循环 N N N 遍的话，那么它的时间复杂度就是 n ∗ O ( l o g 2 N ) n * O(log_2N) n∗O(log2N)，也就是了 O ( n l o g 2 N ) O(nlog_2N) O(nlog2N)

⑤ 平方阶 O ( n 2 ) O(n^2) O(n2)

java 复制代码

for(x = 1; x <= n; x++){
	for(i = 1; i <= n; i++){
		j = i;
		j++;
	}
}

说明：

平方阶 O ( n 2 ) O(n²) O(n2) 就更容易理解了，如果把 O ( n ) O(n) O(n) 的代码再嵌套循环一遍，它的时间复杂度就是 O ( n 2 ) O(n²) O(n2)，这段代码其实就是嵌套了2层 n n n 循环，它的时间复杂度就是 O ( n ∗ n ) O(n*n) O(n∗n)，即 O ( n 2 ) O(n²) O(n2) 如果将其中一层循环的 n n n 改成 m m m ，那它的时间复杂度就变成了 O ( m ∗ n ) O(m*n) O(m∗n)

⑥ 立方阶 O ( n 3 ) O(n^3) O(n3) 和 ⑦ k 次方阶 O ( n k ) O(n^k) O(nk)

说明： 参考上面的 O ( n 2 ) O(n²) O(n2) 去理解就好了， O ( n 3 ) O(n³) O(n3) 相当于3层 n n n 循环，其它的类似。

2.5. 平均时间复杂度和最坏时间复杂度

平均时间复杂度 是指所有可能的输入实例均以等概率出现的情况下，该算法的运行时间。

最坏情况下的时间复杂度称最坏时间复杂度 。一般讨论的时间复杂度均是最坏情况下的时间复杂度。这样做的原因是：最坏情况下的时间复杂度是算法在任何输入实例上运行时间的界限，这就保证了算法的运行时间不会比最坏情况更长。

平均时间复杂度和最坏时间复杂度是否一致，和算法有关(如下图所示)。

排序法	平均时间	最差情况	稳定度	额外空间	备注
冒泡	O ( n 2 ) O(n^2) O(n2)	O ( n 2 ) O(n^2) O(n2)	稳定	O ( 1 ) O(1) O(1)	n n n小的情况较好
交换	O ( n 2 ) O(n^2) O(n2)	O ( n 2 ) O(n^2) O(n2)	不稳定	O ( 1 ) O(1) O(1)	n n n小的情况较好
选择	O ( n 2 ) O(n^2) O(n2)	O ( n 2 ) O(n^2) O(n2)	不稳定	O ( 1 ) O(1) O(1)	n n n小的情况较好
插入	O ( n 2 ) O(n^2) O(n2)	O ( n 2 ) O(n^2) O(n2)	稳定	O ( 1 ) O(1) O(1)	大部分已排序时较好
基数	O ( l o g R B ) O(log_RB) O(logRB)	O ( l o g R B ) O(log_RB) O(logRB)	稳定	O ( n ) O(n) O(n)	B是真数(0~9) R是基数（个十百）
Shell	O ( n l o g n ) O(nlogn) O(nlogn)	O ( n s ) , 1 < s < 2 O(n^s) ,1<s<2 O(ns),1<s<2	不稳定	O ( 1 ) O(1) O(1)	s是所选分组
快速	O ( n l o g n ) O(nlogn) O(nlogn)	O ( n 2 ) O(n^2) O(n2)	不稳定	O ( n l o g n ) O(nlogn) O(nlogn)	n n n大的情况较好
归并	O ( n l o g n ) O(nlogn) O(nlogn)	O ( n l o g n ) O(nlogn) O(nlogn)	稳定	O ( n ) O(n) O(n)	n n n大的情况较好
堆	O ( n l o g n ) O(nlogn) O(nlogn)	O ( n l o g n ) O(nlogn) O(nlogn)	不稳定	O ( 1 ) O(1) O(1)	n n n大的情况较好

3. 算法的空间复杂度

类似于时间复杂度的讨论，一个算法的空间复杂度 (Space Complexity)定义为该算法所耗费的存储空间 ，它也是问题规模 n n n 的函数。

空间复杂度 是对一个算法在运行过程中临时占用存储空间大小的量度。有的算法需要占用的临时工作单元数与解决问题的规模 n n n 有关，它随着 n n n 的增大而增大，当 n n n 较大时，将占用较多的存储单元，例如快速排序、归并排序、基数排序就属于这种情况。

在做算法分析时，主要讨论的是时间复杂度 。从用户使用体验上看，更看重的程序执行的速度。一些缓存产品(redis, memcache)和算法(基数排序)本质就是用空间换时间。