算法系列-排序算法基础概要

常见排序算法分类

算法时间复杂度

概述

度量一个程序(算法）执行时间有下面两种方法：

事后统计的方法

这种方式是可以统计的，但是存在两个问题：
1.想要对设计的算法的运行性能进行评测，需要实际运行此算法程序
2.所度量的时间依赖与计算机运行时的硬件、软件等环境因素
故，这种统计方式 要在同一台计算机的相同状态下运行，才能比较哪个算法速度更快

事前估算的方法

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

时间频度

时间频度基本概念

一个算法花费的时间与算法中语句的执行次数成正比例，算法中语句执行次数多，话费时间就多。一个算法中的语句执行次数成为语句频度或时间频度，记为T(n)。
举例说明：
计算1-100所有数字之和，有两种算法：

1. 使用循环计算：

int total=0；
int end = 100；
for（int i=1;i<=end;i++){
	total+=1;
}

时间频度为：

T(n) = n+1;
这里i<=end也算做一条语句执行，所以不是n而是n+1

2. 直接计算

total = (1+end) * end / 2;

得到时间频度为：

T(n) = 1

时间频度方程常量

首先让我们看下随着n的增大，带常量和不带常量的时间频度方程所得到的频度结果：


从上面结果可以看到，随着n的增大，常量对于得到的时间频度结果影响越来越小。

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

结论：
在计算时间频度时，可以忽略常量

时间频度-低次项

依然直接看例子：

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

结论：
在计算时间频度中，如果包含高次项，则可以忽略低次项

时间频度-系数

随着n值变大，5n^2+7n和3n^2+2n,执行曲线重合，这种场景下，系数5和3可以忽略
n^3+5n和6n^3+4n，随着n的增大执行曲线分离

结论
系数对几次方的影响不同

时间复杂度

概述

定义：
上面我们所说的时间频度为T(n)，我们在定义一个辅助函数f(n)：当n趋近于无穷大时，T(n)/f(n)的极限值为不等于0的常数，如:

T(n)=n^2 + 7n + 5。
f(n) = n^2
当n趋近于无穷大时，这T(n)/f(n) = 1

我们记O(f(n))为算法的渐进时间复杂度，简称时间复杂度。
说明
时间频度T(n)不同，但是时间复杂度可能会相同，例如：

T(n) = n^2+2n+3
T(n)=3n^2+5n+7
虽然两者的时间频度不同，但是其时间复杂度均为O(n^2)

常见时间复杂度

1. 常数阶O(1)
2. 对数阶O(${\log }_{2}n$)
3. 线性阶O(n)
4. 线性对数阶O(n$lo{g}_{2}n$)
5. 平方阶O($n^2$)
6. 立方阶O($n^3$)
7. k次方阶O($n^k$)
8. 指数阶O($2^n$)

说明：
时间复杂度由小到大依次为：
O(1)<O(${\log }_{2}n$)<O(n)<O(n$lo{g}_{2}n$)<O($n^2$)<O($n^3$)<O($n^k$)<O($2^n$)
随着n增大，上述时间复杂度不断增大，算法的执行效率越低。

从上图中可以看出，我们应该尽量避免使用指数阶的算法

常数阶O(1)

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

int i = 1；
int j = 2;
i++;
j++
int tmp = i + j;

上面代码在执行时，它的消耗不会依赖某个变量的增长而变大，那么不论这类代码有多长，我们都可以用O(1)来表示它的时间复杂度。

对数阶O(${\log }_{2}n$)

对数的定义：
如果$N=a^x(a>0,a\ne 1)$,即a的x次方等于N(a>0且$a\ne 1$),那么x叫做以a为底N的对数(logarithm),记作$x={\log }_{a}N$,其中a叫做对数的底数，N叫做真数，x叫做以a为底N的对数

看下面的例子：

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

在while循环里面，每次都将i乘以2，假设x次之后退出循环，也就是2的x次方等于n,$2^x=n$,计算得到$x={\log }_{2}n$，即循环${\log }_{2}n$次后退出循环。因此得出此程序执行的时间复杂度为O(${\log }_{2}n$)

注意： 我们此处的时间复杂度的底数2可以是任何数，可以是3、4…，如上述示例代码中我们将循环体内改为i=i*3,则时间复杂度为O(${\log }_{3}n$)

线性阶O(n)

示例代码：

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

循环的代码会执行n遍，它消耗的时间是随着n的变化而变化的，这类代码都可以用O(n)来表达它的时间复杂度。

线性对数阶O(n$lo{g}_{2}n$)

示例代码：

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

这个就是将时间复杂度为O($lo{g}_{2}n$)的代码循环执行n遍，那么它的时间复杂度为n*O($lo{g}_{2}n$)，也就是O(n$lo{g}_{2}n$)

平方阶O($n^2$)

示例代码：

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

就是将时间复杂度为O(n)代码在循环了一遍，得出O($n^2$)，如果我们将外面一层循环条件改为i<m; 则时间复杂度为O(m*n)

立方阶O($n^3$), k次方阶O($n^k$)

参考平方阶即可，O($n^3$)相当于3次循环，其他的类似。

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

1.平均时间复杂度： 所有可能的输入实例均以等概率出现的情况下，该算法的运行时间
2.最坏时间复杂度： 最坏情况下的时间复杂度，一般讨论的时间复杂度为最坏时间复杂度。最坏时间复杂度是算法任何输入实例的运行时间的上限，这就保证了算法的运行时间不会比最坏的情况更长。

平均时间复杂度和最坏时间复杂度是否一致，和算法有关：

算法的空间复杂度

1. 同时间复杂度类似，一个算法的空间复杂度(Space Complexity)定义为该算法所消耗的存储空间，它也是问题规模n的函数
2. 空间复杂度是对一个算法在运行过程中临时占用存储空间大小的度量。有的算法需要占用的临时工作单元数与解决问题的规模n有关，它随着n的增大而增大，当n较大时，将占用较多的存储单元，例如快速排序和归并排序算法就属于这种情况。
3. 在做算法分析时，主要讨论的是时间复杂度。从用户使用体验上看，更看重的是程序执行的速度。一些缓存产品(redis,memcache)和算法(基数排序)本质就是用空间换时间。