排序

注意：请尊重原创，如有错误请提出并改正，谢谢。（博主：secret_zz）

概述

排序有内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。

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

分类

一、插入排序

1.1  直接插入排序

思想：将一个记录插入到已排序好的有序表中，从而得到一个新，记录数增1的有序表。即：先将序列的第1个记录看成是一个有序的子序列，然后从第2个记录逐个进行插入，直至整个序列有序为止。

要点：设立哨兵，作为临时存储和判断数组边界之用。

示例：

时间复杂度：O（n^2）。

代码：（风格可能略与大家不同，请原谅，后不再说明）

#include<iostream>#include<cstdio>using namespace std;int a[1005],n;int main(){scanf("%d",&n);for (int i=1;i<=n;++i){scanf("%d",&a[i]);}for (int i=1;i<=n;++i){for (int j=i+1;j<=n;++j){if (a[i]>a[j]){swap(a[i],a[j]);}}}for (int i=1;i<=n;++i){if (i!=1){printf(" ");}printf("%d",a[i]);}printf("\n");return 0;}

1.2  希尔排序

思想：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。

要点：

1. 选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
2. 按增量序列个数k，对序列进行k 趟排序；
3. 每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

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

即：先将要排序的一组记录按某个增量d（n/2,n为要排序数的个数）分成若干组子序列，每组中记录的下标相差d.对每组中全部元素进行直接插入排序，然后再用一个较小的增量（d/2）对它进行分组，在每组中再进行直接插入排序。继续不断缩小增量直至为1，最后使用直接插入排序完成排序。

示例：

时间复杂度：O(n*log(n)).

代码：

博主懒，不想写。。

二、选择排序

2.1  简单选择排序

思想：在要排序的一组数中，选出最小（或者最大）的一个数与第1个位置的数交换；然后在剩下的数当中再找最小（或者最大）的与第2个位置的数交换，依次类推，直到第n-1个元素（倒数第二个数）和第n个元素（最后一个数）比较为止。

要点：

第一趟，从n 个记录中找出关键码最小的记录与第一个记录交换；

第二趟，从第二个记录开始的n-1 个记录中再选出关键码最小的记录与第二个记录交换；

以此类推.....

第i 趟，则从第i 个记录开始的n-i+1 个记录中选出关键码最小的记录与第i 个记录交换，

直到整个序列按关键码有序。

示例：

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

代码：

#include<iostream>#include<cstdio>using namespace std;int a[1005],n;int main(){scanf("%d",&n);for (int i=1;i<=n;++i){scanf("%d",&a[i]);}for (int i=2;i<=n;++i){for (int j=1;j<i;++j){while (a[j]<a[i]){j++;}swap(a[j],a[i]);}}for (int i=1;i<=n;++i){if (i!=1){printf(" ");}printf("%d",a[i]);}printf("\n");return 0;}

2.2  二元选择排序

思想：简单选择排序，每趟循环只能确定一个元素排序后的定位。我们可以考虑改进为每趟循环确定两个元素（当前趟最大和最小记录）的位置,从而减少排序所需的循环次数。

要点：改进后对n个数据进行排序，最多只需进行[n/2]趟循环即可。

示例：跟上面差不多。

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

代码：也跟上面差不多。

2.3  堆排序

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

堆的定义如下：具有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）
                              

                              

要点：从算法描述来看，堆排序需要两个过程，一是建立堆，二是堆顶与堆的最后一个元素交换位置。所以堆排序有两个函数组成。一是建堆的渗透函数，二是反复调用渗透函数实现排序的函数。

时间复杂度：O(n*log(n))。

代码：对不起，博主不会。

三、冒泡排序

3.1  简单冒泡排序

思想：在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。

要点：无。

示例：

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

代码：

#include<iostream>#include<cstdio>using namespace std;int a[1005],n;int main(){scanf("%d",&n);for (int i=1;i<=n;++i){scanf("%d",&a[i]);}for (int i=1;i<=n;++i){for (int j=1;j<n;++j){if (a[j]>a[j+1]){swap(a[j],a[j+1]);}}}for (int i=1;i<=n;++i){if (i!=1){printf(" ");}printf("%d",a[i]);}printf("\n");return 0;}

3.2  鸡尾酒排序

思想：鸡尾酒排序即双向的冒泡排序，是冒泡排序的轻微变形。它的主要思路是对于一组无规律排放的数字，先找到最大的数字放到最后一位，在反向找到最小的数字放到第一位。然后再找第二大的数字放到倒数第二位，再找第二小的数字放到第二位。以此类推，直到所有数字有序排列。

要点：无。

示例：

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

代码：

#include<iostream>#include<cstdio>using namespace std;int a[1005],n;int main(){scanf("%d",&n);for (int i=1;i<=n;++i){scanf("%d",&a[i]);}for (int i=1;i<=(n+1)/2;++i){for (int j=1;j<n;++j){if (a[j]>a[j+1]){swap(a[j],a[j+1]);}}for (int j=n;j>1;--j){if (a[j]<a[j-1]){swap(a[j],a[j-1]);}}}for (int i=1;i<=n;++i){if (i!=1){printf(" ");}printf("%d",a[i]);}printf("\n");return 0;}

四、快速排序

4.1 sort快速排序

思想：用函数排序。

要点：无。

示例：

时间复杂度：O(n*log(n))。

代码：

#include<cstdio>#include<algorithm>using namespace std;int a[1005],n;int main(){scanf("%d",&n);for (int i=1;i<=n;++i){scanf("%d",&a[i]);}sort(a+1,a+n+1);for (int i=1;i<=n;++i){if (i!=1){printf(" ");}printf("%d",a[i]);}printf("\n");return 0;}

4.2 Qucik sort快速排序
思想：

1）选择一个基准元素,通常选择第一个元素或者最后一个元素,

2）通过一趟排序讲待排序的记录分割成独立的两部分，其中一部分记录的元素值均比基准元素值小。另一部分记录的 元素值比基准值大。

3）此时基准元素在其排好序后的正确位置

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

要点：无。

示例：同4.1。

时间复杂度：O(n*log(n))。

代码：

#include<iostream>#include<cstdio>using namespace std;int a[1005],n;void qsort(int p,int q){    if(p>=q)    {        return ;    }    int m=(p+q)/2;    swap(a[p],a[m]);    int key=a[p];    int i=p,j=q;    while(i<j)    {        while((a[j]>key)&&(i<j))        {            j--;        }        if(i < j)        {            a[i++] = a[j];        }        while((a[i]<key)&&(i<j))        {            i++;        }        if(i < j)        {            a[j--] = a[i];        }    }    a[i] = key;    qsort(p,i-1);    qsort(i+1,q);}int main(){    scanf("%d",&n);    for(int i=1;i<=n;++i)    {        scanf("%d",&a[i]);    }    qsort(1,n);    for (int i=1;i<=n;++i)    {    if (i!=1)    {    printf(" ");    }    printf("%d",a[i]);    }    printf("\n");    return 0;}

五、归并排序

思想：归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

要点：注意递归出口，不要死循环。

示例：

时间复杂度：O(n*log(n))。

代码：

#include<cstdio>int a[1005],s[1005],n;void merge(int l,int r){int mid=(l+r)/2;if (l==r){return ;}merge(l,mid);merge(mid+1,r);int x=l,y=mid+1,z=l;while ((x<=mid)&&(y<=r)){if (a[x]<=a[y]){s[z++]=a[x++];}else{s[z++]=a[y++];}}for (int i=x;i<=mid;++i){s[z++]=a[i];}for (int i=y;i<=r;++i){s[z++]=a[i];}for (int i=l;i<=r;++i){a[i]=s[i];}return ;}int main(){scanf("%d",&n);for (int i=1;i<=n;++i){scanf("%d",&a[i]);}merge(1,n);for (int i=1;i<=n;++i){if (i!=1){printf(" ");}printf("%d",a[i]);}printf("\n");return 0;}

六、桶排序

思想：

是将阵列分到有限数量的桶子里。每个桶子再个别排序（有可能再使用别的排序算法或是以递回方式继续使用桶排序进行排序）。桶排序是鸽巢排序的一种归纳结果。当要被排序的阵列内的数值是均匀分配的时候，桶排序使用线性时间（Θ（n））。但桶排序并不是 比较排序，他不受到 O(n log n) 下限的影响。
         简单来说，就是把数据分组，放在一个个的桶中，然后对每个桶里面的在进行排序。  

 例如要对大小为[1..1000]范围内的n个整数A[1..n]排序  

 首先，可以把桶设为大小为10的范围，具体而言，设集合B[1]存储[1..10]的整数，集合B[2]存储   (10..20]的整数，……集合B[i]存储(   (i-1)*10,   i*10]的整数，i   =   1,2,..100。总共有  100个桶。  

  然后，对A[1..n]从头到尾扫描一遍，把每个A[i]放入对应的桶B[j]中。  再对这100个桶中每个桶里的数字排序，这时可用冒泡，选择，乃至快排，一般来说任  何排序法都可以。

  最后，依次输出每个桶里面的数字，且每个桶中的数字从小到大输出，这  样就得到所有数字排好序的一个序列了。  

  假设有n个数字，有m个桶，如果数字是平均分布的，则每个桶里面平均有n/m个数字。如果  

  对每个桶中的数字采用快速排序，那么整个算法的复杂度是  

  O(n   +   m   *   n/m*log(n/m))   =   O(n   +   nlogn   -   nlogm)  

  从上式看出，当m接近n的时候，桶排序复杂度接近O(n)  

  当然，以上复杂度的计算是基于输入的n个数字是平均分布这个假设的。这个假设是很强的  ，实际应用中效果并没有这么好。如果所有的数字都落在同一个桶中，那就退化成一般的排序了。  

要点：

前面说的几大排序算法 ，大部分时间复杂度都是O（n^2），也有部分排序算法时间复杂度是O(n*log（n）)。而桶排序却能实现O（n）的时间复杂度。但桶排序的缺点是：

        1）首先是空间复杂度比较高，需要的额外开销大。排序有两个数组的空间开销，一个存放待排序数组，一个就是所谓的桶，比如待排序值是从0到m-1，那就需要m个桶，这个桶数组就要至少m个空间。

        2）其次待排序的元素都要在一定的范围内等等。

       桶式排序是一种分配排序。分配排序的特定是不需要进行关键码的比较，但前提是要知道待排序列的一些具体情况。

示例：无。
时间复杂度：O(n)。

代码：

#include<cstdio>int a[1005],s[10000005],n,m,f;int main(){scanf("%d",&n);for (int i=1;i<=n;++i){scanf("%d",&a[i]);s[a[i]]++;if (a[i]>m){m=a[i];}}for (int i=0;i<=m;++i){for (int j=1;j<=s[i];++j){if (f==1){printf(" ");}f=1;printf("%d",i);}}printf("\n");return 0;}

其实还有很多种排序，在这里不再一一赘述了哈。（让博主高(de)兴(se)一下吧。。）

总结

各种排序的稳定性，时间复杂度和空间复杂度总结：

我们比较时间复杂度函数的情况：

时间复杂度函数O(n)的增长情况：

                       ↑↑↑看到差距了吧。很不赶快用好一点的算法！

所以对于n较大的排序记录。一般的选择都是时间复杂度为O(n*log（n）)的排序方法。