史上最全面的八种排序算法总结

排序包括内部排序和外部排序。内部排序是对内存中的数据记录进行排序，而外部排序是因为排序后的数据非常大，无法一次性容纳所有已排序的记录。在排序过程中，需要访问外部存储器。

我们这里所说的八大排名都是内部排名。

当n很大时，应该使用时间复杂度为O(nlog2n)的排序方法：快速排序、堆排序或归并排序。

快速排序：目前认为是基于比较的内部排序中最好的方法。当待排序关键字随机分布时，快速排序的平均时间最短；

1.插入排序——直接插入排序

基本理念：

向已排序的有序列表中插入一条记录，得到一个新的有序列表，记录数加1。即：先将序列的第一条记录视为有序子序列，然后逐条插入第二条记录，直到整个序列是有序的。

要点：设置哨兵，用于临时存储和判断数组边界。

直接插入排序示例：

如果遇到与插入元素相等的元素，则插入元素将要插入的元素放在相等元素之后。因此，相等元素的顺序没有改变。原来的无序序列的顺序就是排序后的顺序，所以插入排序是稳定的。

算法的实现：

[cpp] 查看普通副本打印？

无效打印（int a []，int n，int i）{

库蒂':'；

for(int j=0; j8; j++){

库塔[j] ' ';

}

库滕德尔；

}

void InsertSort(int a[], int n)

{

for(int i=1; in; i++){

if(a[i] a[i-1]){ //如果第i个元素大于第i-1个元素，则直接插入。如果小于，则移动已排序的列表并插入。

整数j=i-1；

a[i]=a[i-1]; //将一个元素逐个移动

while(x a[j]){ //在有序列表中查找插入位置

a[j+1]=a[j];

j——； //将元素向后移动

}

a[j+1]=x； //插入到正确的位置

}

打印（a，n，i）； //打印每次排序的结果

}

}

int main(){

int a[8]={3,1,5,7,2,4,9,6};

插入排序(a,8);

打印（a,8,8）；

}

效率：

时间复杂度：O(n^2)。

其他插入排序包括二元插入排序和2路插入排序。

2.插入排序——希尔排序（Shell`s Sort）

希尔排序法是由D.L. 提出的。 Shell于1959年提出，是对直接排序的很大改进。希尔排序也称为减少增量排序。

基本思想：

首先将整个待排序记录序列分成若干子序列进行直接插入排序。当整个序列中的记录“基本有序”时，则直接对所有记录进行插入排序。

操作方法：

选择增量序列t1,t2,tk，其中titj,tk=1；

根据增量序列数k对序列进行k次排序；

在每次排序过程中，将待排序列根据对应的增量ti分成若干个长度为m的子序列，对每个子表进行直接插入排序。只有当增量因子为1时，整个序列才被当作一个表来处理，表的长度就是整个序列的长度。

希尔排序示例：

算法实现：

我们简单处理增量序列：增量序列d={n/2,n/4, n/8.1} n 为要排序的数字个数

即：首先将一组待排序记录按照一定的增量d（n/2，n为待排序数的个数）划分为若干组子序列，每组记录的下标相差d.对于每组中的所有记录元素通过直接插入进行排序，然后按更小的增量（d/2）进行分组，并在每组内再次排序。继续减少增量，直到为1，最后使用直接插入排序完成排序。

[cpp] 查看普通副本打印？

无效打印（int a []，int n，int i）{

库蒂':'；

for(int j=0; j8; j++){

库塔[j] ' ';

}

库滕德尔；

}

/**

* 直接插入排序的一般形式

*

* @param int dk 减少增量。如果是直接插入排序，dk=1

*

*/

void ShellInsertSort(int a[], int n, int dk)

{

for(int i=dk; in; ++i){

if(a[i] a[i-dk]){ //如果第i个元素大于第i-1个元素，则直接插入。如果小于，则移动已排序的列表并插入。

int j=i-dk；

a[i]=a[i-dk]; //首先向后移动一个元素

while(x a[j]){ //在有序列表中查找插入位置

a[j+dk]=a[j];

j-=dk； //将元素向后移动

}

a[j+dk]=x； //插入到正确的位置

}

打印（a，n，i）；

}

}

/**

* 首先按照增量d进行希尔排序（n/2，n为要排序的数字个数）

*

*/

void shellSort(int a[], int n){

int dk=n/2;

而（dk=1）{

ShellInsertSort(a, n, dk);

dk=dk/2；

}

}

int main(){

int a[8]={3,1,5,7,2,4,9,6};

//ShellInsertSort(a,8,1); //直接插入排序

shellSort(a,8); //希尔插入排序

打印（a,8,8）；

}

希尔排序时效性分析比较困难。键码比较的次数和记录的移动的次数取决于增量因子序列d的选择。在某些情况下，可以准确估计键码比较次数和记录的走法次数。目前还没有人给出一种选择最佳增量因子序列的方法。增量因子序列可以采用多种方式获取，包括奇数和素数。但需要注意的是，增量因子之间除1外没有其他公共因子，最后的增量因子必须为1。希尔排序方法是一种不稳定的排序方法。

3. 选择排序——简单选择排序

基本思想：

在一组待排序的数字中，选择最小（或最大）的数字，与第一个位置的数字交换；然后找到剩余数字中最小（或最大）的数字，并将其与第二位置的数字交换。交换，依此类推，直到第n-1 个元素（倒数第二个数字）和第n 个元素（最后一个数字）进行比较。

简单选择排序的示例：

操作方法：

第一遍，找到n条记录中关键码最小的记录，与第一条记录交换；

第二遍，从第二条记录开始的n-1条记录中选择关键码最小的记录，与第二条记录交换；

等等.

对于第i遍，从第i条记录开始的n-i+1条记录中选择具有最小密钥码的记录并与第i条记录交换。

直到整个序列按key排序。

算法实现：

[cpp] 查看普通副本打印？

无效打印（int a []，int n，int i）{

cout'第'i+1'行：';

for(int j=0; j8; j++){

库塔[j] ' ';

}

库滕德尔；

}

/**

* 数组的最小值

*

* @return int 数组的键值

*/

int SelectMinKey(int a[], int n, int i)

{

整数k=i；

for(int j=i+1;j n;++j) {

if(a[k] a[j]) k=j;

}

返回k；

}

/**

* 选择排序

*

*/

无效selectSort(int a[], int n){

int 键，tmp；

for(int i=0; i n; ++i) {

key=SelectMinKey(a, n,i); //选择最小的元素

如果（键！=我）{

tmp=a[i]; a[i]=a[键]; a[键]=tmp; //最小元素与第i个元素互换

}

打印（a，n，i）；

}

}

int main(){

int a[8]={3,1,5,7,2,4,9,6};

cout'初始值：';

for(int j=0; j8; j++){

库塔[j] ' ';

}

库滕德伦德尔；

选择排序（a，8）；

打印（a,8,8）；

}

简单选择排序的改进—— 二元选择排序

在简单选择排序中，每次循环只能确定排序后一个元素的位置。我们可以考虑改进每次循环对两个元素（当前最大和最小记录）的定位，从而减少排序所需的循环次数。改进后，排序n个数据最多只需要[n/2]次循环。具体实现如下：

[cpp] 查看普通副本打印？

void SelectSort(int r[],int n) {

int i，j，最小值，最大值，tmp；

for (i=1;i=n/2;i++) {

//进行不超过n/2 个选择排序操作

最小值=我；最大值=我； //分别记录最大和最小关键字记录位置

for (j=i+1; j=n-i; j++) {

if (r[j] r[max]) {

最大值=j ；继续；

}

if (r[j] r[min]) {

最小值=j ；

}

}

//这个交换操作也可以具体情况具体讨论，提高效率。

tmp=r[i-1]; r[i-1]=r[最小值]； r[分钟]=tmp；

tmp=r[n-i]; r[n-i]=r[最大值]； r[最大值]=tmp；

}

}

4.选择排序——堆排序

堆排序是一种树选择排序，是对直接选择排序的有效改进。

基本思想：

堆的定义如下：n个元素的序列(k1,k2,kn)，当且仅当

它被称为堆。从堆的定义可以看出，堆顶元素（即第一个元素）一定是最小项（小顶堆）。

如果将堆存储为一维数组，则堆对应于一棵完全二叉树，所有非叶子节点的值不大于（或不小于）其子节点的值，根节点（堆顶元素）的值最小（或最大）。喜欢：

(a) 大顶堆序列：(96,83,27,38,11,09)

(b) 最小堆序列：(12, 36, 24, 85, 47, 30, 53, 91)

最初，将待排序的n个数的序列视为一个顺序存储的二叉树（一维数组存储二叉树），调整它们的存储顺序，使其成为一个堆，输出堆顶元素即可得到n 个元素。堆中最小（或最大）的元素，则堆的根节点数最小（或最大）。然后重新调整前（n-1）个元素组成堆，输出堆顶元素，得到n个元素中第二小（或第二大）的元素。以此类推，直到出现一个只有两个节点的堆，将它们交换，最后得到n个节点的有序序列。将此过程称为堆排序。

因此，实现堆排序需要解决两个问题：

1.如何构建n个要排序的数字到堆中；

2、输出堆顶元素后，如何调整剩余的n-1个元素，使其成为新的堆。

我们先讨论第二个问题：输出堆顶元素后，用剩余的n-1个元素重建堆的调整过程。

如何调整小顶堆：

1）有一个有m个元素的堆。输出堆顶元素后，还剩下m-1个元素。堆底的元素被发送到堆顶（（最后一个元素与堆顶交换），堆被销毁。唯一的原因是根节点不满足属性堆的。

2）将根节点与左右子树中较小的元素交换。

3）如果与左子树交换：如果左子树堆被破坏，即左子树的根节点不满足堆的属性，则重复方法（2）。

4）如果与右子树交换，如果右子树堆被破坏，即右子树的根节点不满足堆的性质。然后重复方法（2）。

5）继续对不满足堆属性的子树进行上述交换操作，直到叶子节点和堆构建完毕。

这种从根节点到叶节点的调整过程称为筛选。如图所示：

我们来讨论一下最初构建一个包含n 个元素的堆的过程。

堆建法：初始序列建堆的过程是一个反复筛选的过程。

1）一棵有n个节点的完全二叉树，那么最后一个节点就是

节点的子树。

2) 过滤

从以节点为根的子树开始，子树变成堆。

3）然后，向前过滤以每个节点为根的子树，形成堆，直到根节点。

如图，构建堆的初始过程：无序序列：(49,38,65,97,76,13,27,49)

算法的实现：

从算法描述来看，堆排序需要两个过程，一是建立堆，二是堆顶和堆最后一个元素之间交换位置。所以堆排序由两个函数组成。一是构建堆的穿透函数，二是重复调用穿透函数实现排序的函数。

[cpp] 查看普通副本打印？

无效打印（int a []，int n）{

for(int j=0; jn; j++){

库塔[j] ' ';

}

库滕德尔；

}

/**

* 已知H[s.m]除H[s]外均满足堆的定义

* 调整H[s]使其成为一个大的顶堆。即过滤以第s个节点为根的子树，

*

* @param H 为要调整的堆数组

* @param s 为要调整的数组元素的位置

* @param length 是数组的长度

*

*/

void HeapAdjust(int H[],int s, int 长度)

{

int tmp=H[s];

int 子级=2*s+1; //左子节点的位置。 （i+1为当前调整节点右子节点的位置）

while（子长度）{

if(child+1 length H[child]H[child+1]) { //如果右孩子大于左孩子（找到比当前节点大的子节点进行调整）

++孩子；

}

if(H[s]H[child]) { //如果较大的子节点比父节点大

H[s]=H[子]； //然后将较大的子节点向上移动并替换其父节点

s=孩子； //重置s，即下一个要调整的节点的位置

孩子=2*s+1;

} else { //如果当前要调整的节点大于其左右子节点，则无需调整，直接退出

休息；

}

H[s]=tmp； //将当前要调整的节点放置到比它大的子节点的位置。

}

打印（高度，长度）；

}

/**

* 调整初始堆

* 将H[0.length-1] 构建成堆

* 调整后第一个元素为序列中最小的元素

*/

void BuildingHeap(int H[], int length)

{

//最后一个有子节点的位置i=(length -1)/2

for (int i=(长度-1)/2 ; i=0; --i)

HeapAdjust(H,i,长度);

}

/**

* 堆排序算法

*/

void HeapSort(int H[],int 长度)

{

//初始堆

BuildingHeap(H, 长度);

//调整从最后一个元素开始的顺序

for (int i=长度- 1; i 0; --i)

{

//交换堆顶元素H[0]和堆最后一个元素

int 温度=H[i]; H[i]=H[0]； H[0]=温度；

//每次交换堆顶元素和堆最后一个元素后，必须对堆进行调整

堆调整(H,0,i);

}

}

int main(){

int H[10]={3,1,5,7,2,4,9,6,10,8};

cout'初始值：';

打印（H，10）；

堆排序(H,10);

//选择排序(a, 8);

cout'结果：';

打印（H，10）；

}

分析：

设树深度为k。从根到叶子过滤时，元素比较次数最多为2(k-1)次，记录最多交换k次。因此，堆建好后，排序过程中的筛选次数不超过以下公式：

构建堆时的比较次数不超过4n，因此堆排序最坏情况的时间复杂度为：O(nlogn)。

5.交换排序——冒泡排序（Bubble Sort）

基本思想：

在一组待排序的数字中，对范围内所有尚未排序的数字，从上到下依次比较和调整相邻的两个数字，使较大的数字向下沉，较大的数字向下沉。小的向上升起。即：每当比较两个相邻的数字，发现其顺序与排序要求相反时，就将它们交换。

冒泡排序示例：

算法的实现：

[cpp] 查看普通副本打印？

void bubbleSort(int a[], int n){

for(int i=0; i n-1; ++i) {

for(int j=0; j n-i-1; ++j) {

if(a[j] a[j+1])

{

int tmp=a[j] ; a[j]=a[j+1] ; a[j+1]=tmp；

}

}

}

}

冒泡排序算法的改进

1. 设置一个地标变量pos 来记录每次排序过程中最后一次交换的位置。由于pos 位置之后的记录已就位交换，因此在下一次排序过程中仅扫描pos 位置。

改进后的算法如下：

[cpp] 查看普通副本打印？

void Bubble_1 (int r[], int n) {

整数i=n -1; //最初，最后一个位置保持不变

而（我0）{

整数位置=0； //每趟开始时，不进行记录交换

for (int j=0; j i; j++)

如果（r[j] r[j+1]）{

位置=j； //记录兑换位置

int tmp=r[j]; r[j]=r[j+1]; r[j+1]=tmp；

}

我=位置； //为下一步排序做准备

}

}

2.传统冒泡排序中，每次排序操作只能找到一个最大值或最小值。我们考虑采用在每次排序操作中进行正向冒泡和反向冒泡的方法，一次性获得两个最终值（最大的一个）。和最小），从而将排序次数减少了近一半。

改进后的算法实现为：

[cpp] 查看普通副本打印？

void Bubble_2 (int r[], int n){

int 低=0;

int 高=n -1; //设置变量的初始值

int tmp，j；

而（低高）{

for (j=low; j high; ++j) //正向冒泡，找到最大的

如果（r[j] r[j+1]）{

tmp=r[j]; r[j]=r[j+1]; r[j+1]=tmp；

}

- 高的； //修改高位值并向前移动一位

for (j=high; jlow; --j) //反转气泡，找到最小的一个

如果（r[j]r[j-1]）{

tmp=r[j]; r[j]=r[j-1]; r[j-1]=tmp；

}

++低； //修改低位值并向后移动一位

}

}

6.交换排序——快速排序

基本思想：

1）选择一个基本元素，通常是第一个元素或最后一个元素，

2）通过一轮排序，将待排序的记录分为两个独立的部分，并且其中一部分记录的元素值小于参考元素值。另一部分记录的元素值大于基值。

3）此时，参考元素排序后已处于正确位置。

4）然后继续用同样的方式对两部分记录进行排序，直到整个序列有序。

快速排序示例：

(a) 一次排序过程：

(b) 排序全过程

算法的实现：

递归实现：

[cpp] 查看普通副本打印？

无效打印（int a []，int n）{

for(int j=0; jn; j++){

库塔[j] ' ';

}

库滕德尔；

}

无效交换（int *a，int *b）

{

int tmp=*a;

*a=*b；

*b=tmp；

}

int 分区(int a[], int low, int high)

{

int privotKey=a[低]; //基本元素

while(low high){ //从表格两端向中间交替扫描

while(low high a[high]=privotKey) --high; //从high指向的位置向前查找，一直到low+1的位置。将小于底端的元素交换到下端

交换（a[低]，a[高]）；

while(low high a[low]=privotKey ) ++low;

交换（a[低]，a[高]）；

}

打印（a，10）；

返回低位；

}

void fastSort(int a[], int low, int high){

如果（低高）{

int privotLoc=分区(a, 低， 高); //将表分成两部分

快速排序（a，低，privotLoc -1）； //对低位子表递归排序

QuickSort(a, privotLoc + 1, 高); //对高位子表递归排序

}

}

int main(){

int a[10]={3,1,5,7,2,4,9,6,10,8};

cout'初始值：';

打印（a，10）；

快速排序(a,0,9);

cout'结果：';

打印（a，10）；

}

分析：

快速排序通常被认为是同数量级排序方法中平均性能最好的（O(nlog2n)）。但如果初始序列是按键排序或者基本排序的话，快速排序就会退化为冒泡排序。为了改进它，通常采用“三合一法”来选择基准记录，即将以两个端点为中心的三个记录键和排序区间的中点调整为支点记录。快速排序是一种不稳定的排序方法。

快速排序改进

在该改进算法中，仅对长度大于k的子序列递归调用快速排序，使原始序列基本有序，然后使用插入排序算法对整个基本有序序列进行排序。实践证明，改进算法的时间复杂度有所降低，且当k取8左右时，改进算法性能最佳。算法思想如下：

[cpp] 查看普通副本打印？

无效打印（int a []，int n）{

for(int j=0; jn; j++){

库塔[j] ' ';

}

库滕德尔；

}

无效交换（int *a，int *b）

{

int tmp=*a;

*a=*b；

*b=TM