八种基本的排序算法

一.、直接插入排序算法(数组存储)

1.n个待排元素，分成两部分，有序部分和无序部分

2.初始：有序段：a[0]

无序段：a[1]--a[n]

3.算法实现思想

从无序中取出一个元素a[i]和有序区间元素进行比较，并且将其插入合适的位置，插入位置之后的元素要后移。

例：

{3，2，5，8，4，7，6，9}

{3}{2，5，8，4，7，6，9}

{2，3}{5，8，4，7，6，9}

{2，3，5}{8，4，7，6，9}

{2，3，5，8}{4，7，6，9}

{2，3，4，5，8}{7，6，9}

{2，3，4，5，7，8}{6，9}

{2，3，4，5，6，7，8}{9}

{2，3，4，5，6，7，8，9}

4.算法实现

void IninsertSort(inr a[],int n)

{

int i,j,x;

for(i=1;i<n;i++)

{

x=a[i];

for(j=i-1;j>-1&&a[j]>x;j--)

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

a[j+1]=x;

}

}

5.算法性能及其优化

空间复杂度：O(1)

时间复杂度：O(n2)

稳定性：稳定

优化：插入时对有序段从后向前查找；

找要插入的元素的位置时对有序段进行二分查找

二、冒泡排序（数组存储）

1.n个元素排完序最多经过n-1趟

2.算法实现思想

假如一组数按从小到大排序，对该组数进行两两比较，看是否需要交换，如果需要交换就交换，不需要交换就不用交换继续继续想下执行，直到这些元素都被比较过一遍之后，有一个元素放在了他最终的位置上（即：第一个或者最后一个）

例：

{3，5，6，4，2，7}

{2，3，5，6，4，7}

{2，3，4，5，6，7}

3.算法实现

void BubbleSort(int a[],int n)

{

int i,j,t;

for(i=0;i><n-1;i++)

{

for(j=n-1;j>i;j--)

{

if(a[j]>a[j-1])

{

t=a[j];

a[j]=a[j-1];

a[j-1]=t;

}

}

}

}

注：该过程需要把所有的过程跑完才结束

4.算法性能及其优化

空间复杂度：O(1)

时间复杂度：O(n2)

稳定性：稳定

优化：对外层循环设置标记符flag,只要所以元素都按顺序排完了就输出，不需要所有的都跑完；

对内层循环，从后边向前边往出冒元素

实现代码如下：

void BubbleSort(int a[],int n)

{

int i,j,t,tag;

for(i=0;i<n-1;i++)

{

tag=0;

for(j=n-1;j>i;j--)

{

t=a[j];

a[j]=a[j-1];

a[j-1]=t;

tag=1;

}

if(!tag) break;

}

}

三、快速排序

1.基本思想

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

（2）通过一次排序，将待排序记录分割成两部分，其中一部分记录不基准元素小的元素，一部分记录比基准元素大的元素

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

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

例：

2算法实现：

递归实现：

void QuickSort(int a[],int low,int high)

{

int i, j, x;

if (low <high)

{

i = low;

j = high;

x = a[i];

while (i < j)

{

while(i < j && a[j] > x)

j--; /* 从右向左找第一个小于x的数 */

if(i < j)

a[i] = a[j];

while(i < j && a[i] < x)

i++; /* 从左向右找第一个大于x的数 */

if(i < j)

a[j] = a[i];

}

a[i] = x;

QuickSort(a, low, i-1); /* 递归调用 */

QuickSort(a, i+1, high);

}

}

非递归排序：

#include<stdio.h>

#define N 7

void QuickSort(int a[],int n)

{

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

{

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

{

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

{

int t=a[j];

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

a[j+1]=t;

}

}

}

}

//void QuickSort(int a[],int n)

//{

// for(int i=0;i<n;i++)

// {

// for(int j=i;j<n;j++)

// {

// if(a[i]>a[j])

// {

// int t=a[i];

// a[i]=a[j];

// a[j]=t;

// }

// }

// }

//}

3.算法性能及其优化

空间复杂度：O(1)

时间复杂度：O(n2) 最好情况 O(nlogn)

稳定性：不稳定

优化： 在本改进算法中 , 只对长度大于 k 的子序列递归调用快速排序 , 让原序列基本有序，然后再对整个基本有序序列用插入排序算法排序。实践证明，改进后的算法时间复杂度有所降低，且当 k 取值为  8  左右时 , 改进算法的性能最佳。算法思想如下:(连链接中有优化后的代码)

四、希尔排序

1.算法思想

先将整个待排序的记录序列分割成若干子序列分别进行插入排序，待整个序列中的记录基本有序时在对整体进行一次直接插入排序

操作如下：

选择一个增量序列个数k,对序列进行k趟排序，每趟排序，根据对应的增量d，将待排序列分成长度为m的子序列，分别对各自的表进行直接插入排序，尽因增量为1时，整个序列作为一个表来处理，表长度为整个序列的长度

例：

3.算法实现

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

void ShellSort(int a[],int n)

{

int i,j,x;

int d=n/2;

while(d>=1)

{

for(i=d;i<n;i++)

{

x=a[i];

for(j=i-d;j>=0;j-=d)

{

if(a[j]>x)

a[j+d]=a[j];

else

break;

}

a[j+d]=x;

}

d=d/2;

}

}

4.算法性能及其优化

空间复杂度：O(1)

时间复杂度：O(n2) 最好情况 O(nlogn)

稳定性：不稳定

五、简单选择排序

1.算法思想

设所有元素的第一个元素为最大的元素（或者最小的元素），然后用第一个元素与其他元素比较，找到其中最大的（或最小的）和第一个元素交换，一次排序完，数组中第一个位置上放的是该序列完成排序后元素缩放的位置。（即一次排序完之后肯定有一个元素放到正确的位置上，后边在比较时就不用再考虑这些元素）

2.算法实现

void SelectSort(int a[],int n)

{

int i,j,kmin,t;

for(i=0;i<n;i++)

{

kmin=i;

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

{

if(a[kmin]>a[j])

kmin=j;

}

if(i!=kmin)

{

t=a[i];

a[i]=a[kmin];

a[kmin]=t;

}

}

}

3.算法性能及其优化

空间复杂度：O(1)

时间复杂度：O(n2)

稳定性：不稳定

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

void  SelectSort( int  r[], int  n) {       · int  i ,j , min ,max, tmp;  

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

         // 做不超过n/2趟选择排序    

        min = i; max = i ;  //分别记录最大和最小关键字记录位置   

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

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

                max = j ;  continue  ;   

            }    

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

                min = j ;   

            }     

       }    

       //该交换操作还可分情况讨论以提高效率   

       tmp = r[i-1]; r[i-1] = r[min]; r[min] = tmp;  

      tmp = r[n-i]; r[n-i] = r[max]; r[max] = tmp;   

  

     }   

}  

六、归并排序

1.算法思想

是将两个或者是两个以上的有序表合成一个新的有序表，即把待排序列分成若干个子序列，每个子序列是有序的，然后把有序子序列合并成整体有序序列

例如： 归并排序示例：

2.算法实现

（1）递归实现

//实现归并，并把数据都放在list1里面

void merging(int *list1,int list1_size,int *list2,int list2_size)

{

int i,j,k,m;

i = j = k = 0;

int temp[MAXSIZE]；

while(i<list1_size&&j<list2_size)

{

if(list1[i] < list2[j])

{

temp[k++] = list1[i++];

}

else

{

temp[k++] = list2[j++];

}

}

//如果有剩下的，那么说明就是它是比前面的数组都大的，直接加入就可以了

while(i<list1_size)

{

temp[k++] = list1[i++];

}

while(j<list2_size)

{

temp[k++] = list2[j++];

}

for(m=0; m<(list1_size + list2_size);m++)

{

list1[m] = temp[m];

}

}

void MergeSort(int k[],int n)

{

if(n>1)

{

int *list1 = k; //定义一个指针变量，指向数组k的地址

int list1_size = n/2; //数组的长度分为本来数组长度的一半

int *list2 = k +n/2; //定义另外一个指针变量，指向数组k+n/2的地址

int list2_size = n - list1_size;//长度为刚才总的减去刚才分去那一半

MergeSort(list1,list1_size); //调用数组本身，相当与递归，

MergeSort(list2,list2_size); //调用数组本身，相当与递归

merging(list1,list1_size,list2,list2_size);

}

}

（2）迭代实现

void MergeSort(int k[],int n)

{

int i,next,left_min,left_max,right_min,right_max;

//开辟一个与原来数组一样大小的空间用来存储用

int *temp = (int *)malloc(n * sizeof(int));

//逐级上升，第一次比较2个，第二次比较4个，第三次比较8个。。。

for(i=1; i<n; i*=2)

{

//每次都从0开始，数组的头元素开始

for(left_min=0; left_min<n-i; left_min = right_max)

{

right_min = left_max = left_min + i;

right_max = left_max + i;

//右边的下标最大值只能为n

if(right_max>n)

{

right_max = n;

}

//next是用来标志temp数组下标的，由于每次数据都有返回到K，

//故每次开始得重新置零

next = 0;

//如果左边的数据还没达到分割线且右边的数组没到达分割线，开始循环

while(left_min<left_max&&right_min<right_max)

{

if(k[left_min] < k[right_min])

{

temp[next++] = k[left_min++];

}

else

{

temp[next++] = k[right_min++];

}

}

//上面循环结束的条件有两个，如果是左边的游标尚未到达，那么需要把

//数组接回去，可能会有疑问，那如果右边的没到达呢，其实模拟一下就可以

//知道，如果右边没到达，那么说明右边的数据比较大，这时也就不用移动位置了

while(left_min < left_max)

{

//如果left_min小于left_max，说明现在左边的数据比较大

//直接把它们接到数组的min之前就行

k[--right_min] = k[--left_max];

}

while(next>0)

{

//把排好序的那部分数组返回该k

k[--right_min] = temp[--next];

}

}

}

}

3.算法性能及其优化

空间复杂度：O(n+logN)

时间复杂度：O(nlog(n))

稳定性：不稳定

优化：两路归并的递算法：

void  MSort(ElemType *r, ElemType *rf, int  s,  int  t)  

{   

    ElemType *rf2;  

    if (s==t) r[s] = rf[s];  

     else   

   {   

         int  m=(s+t)/2;           /*平分*p 表*/   

        MSort(r, rf2, s, m);         /*递归地将p[s…m]归并为有序的p2[s…m]*/   

        MSort(r, rf2, m+1, t);       /*递归地将p[m+1…t]归并为有序的p2[m+1…t]*/   

        Merge(rf2, rf, s, m+1,t);    /*将p2[s…m]和p2[m+1…t]归并到p1[s…t]*/   

    }  

}  

void  MergeSort_recursive(ElemType *r, ElemType *rf,  int  n)  

{    /*对顺序表*p 作归并排序*/   

    MSort(r, rf,0, n-1);  

}  

七、堆排序

1.算法思想

堆排序是一种树形选择排序，是对直接选择排序的有效改进。（形成的树一定为完全二叉树）

堆的定义如下：具有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 个元素，使其成为一个新堆。

2.算法实现

void Make_Heap(int a[],int end)

{

int pa,t,tag=1;

while(tag)

{

pa=end/2;

tag=0;

while(pa>0)

{

if(a[pa]<a[2*pa])

{

t=a[pa];

a[pa]=a[2*pa];

a[2*pa]=t;

tag=1;

}

if(2*pa+1<=end&&a[pa]<a[2*pa+1])

{

t=a[pa];

a[pa]=a[2*pa+1];

a[2*pa+1]=t;

tag=1;

}

pa--;

}

}

}

void HeapSort(int a[])

{

int pa,p;

int end=N;

while(end>1)

{

Make_Heap(a,end);

//交换头结点好尾节点

p=a[1];

a[1]=a[end];

a[end]=p;

end--;

}

}

3.算法性能及其优化

空间复杂度：O(1)

时间复杂度：最坏 O(nlogn )

稳定性：不稳定

优化：无

八、基数排序（桶排序）

桶排序的基本思想：将阵列分布到游戏那数量的桶子里，每个桶子再个别排序（有可能在使用别的排序算法或是以递回方式继续使用桶排序进行排序），桶排序是鸽巢排序的一种归纳结果。当要被排序的阵列内的数值是均匀分配的时候，桶排序使用线性时间(O(n)).但桶排序并不是比较排序，他不受到O(nlogn)下限的影响

简单来说，就是把数据分组，放在一个个的桶中，然后对每个桶里面的在进行排序。

例如要对大小为[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（n2），也有部分排序算法时间复杂度是O(nlogn)。而桶式排序却能实现O（n）的时间复杂度。但桶排序的缺点是：

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

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

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

分配排序的基本思想： 说白了就是进行多次的桶式排序。

基数排序过程无须比较关键字，而是通过“分配”和“收集”过程来实现排序。它们的时间复杂度可达到线性阶：O(n)。

实例:

扑克牌中52 张牌，可按花色和面值分成两个字段，其大小关系为：

花色：  梅花< 方块< 红心< 黑心  

面值：  2 < 3 < 4 < 5 < 6 < 7 < 8 < 9 < 10 < J < Q < K < A

若对扑克牌按花色、面值进行升序排序，得到如下序列：

即两张牌，若花色不同，不论面值怎样，花色低的那张牌小于花色高的，只有在同花色情况下，大小关系才由面值的大小确定。这就是多关键码排序。

为得到排序结果，我们讨论两种排序方法。

方法1 ：先对花色排序，将其分为4 个组，即梅花组、方块组、红心组、黑心组。再对每个组分别按面值进行排序，最后，将4 个组连接起来即可。

方法2 ：先按13 个面值给出13 个编号组(2 号，3 号，...，A 号)，将牌按面值依次放入对应的编号组，分成13 堆。再按花色给出4 个编号组(梅花、方块、红心、黑心)，将2号组中牌取出分别放入对应花色组，再将3 号组中牌取出分别放入对应花色组，……，这样，4 个花色组中均按面值有序，然后，将4 个花色组依次连接起来即可。

设n 个元素的待排序列包含d 个关键码{k1，k2，…，kd}，则称序列对关键码{k1，k2，…，kd}有序是指：对于序列中任两个记录r[i]和r[j](1≤i≤j≤n)都满足下列有序关系：

                                                               

其中k1 称为最主位关键码，kd 称为最次位关键码     。

两种多关键码排序方法：

多关键码排序按照从最主位关键码到最次位关键码或从最次位到最主位关键码的顺序逐次排序，分两种方法：

最高位优先(Most Significant Digit first)法，简称MSD 法 ：

1）先按k1 排序 分组 ，将序列分成若干子序列，同一组序列的记录中，关键码k1 相等。

2）再对各组按k2 排序分成子组，之后，对后面的关键码继续这样的排序分组，直到按最次位关键码kd 对各子组排序后。

3）再将各组连接起来，便得到一个有序序列。扑克牌按花色、面值排序中介绍的方法一即是MSD 法。

最低位优先(Least Significant Digit first)法，简称LSD 法 ：

1) 先从kd 开始排序，再对kd-1进行排序，依次重复，直到按k1排序分组分成最小的子序列后。

2) 最后将各个子序列连接起来，便可得到一个有序的序列, 扑克牌按花色、面值排序中介绍的方法二即是LSD 法。

基于LSD方法的链式基数排序的基本思想

　　“多关键字排序”的思想实现“单关键字排序”。对数字型或字符型的单关键字，可以看作由多个数位或多个字符构成的多关键字，此时可以采用“分配-收集”的方法进行排序，这一过程称作基数排序法，其中每个数字或字符可能的取值个数称为基数。比如，扑克牌的花色基数为4，面值基数为13。在整理扑克牌时，既可以先按花色整理，也可以先按面值整理。按花色整理时，先按红、黑、方、花的顺序分成4摞（分配），再按此顺序再叠放在一起（收集），然后按面值的顺序分成13摞（分配），再按此顺序叠放在一起（收集），如此进行二次分配和收集即可将扑克牌排列有序。   

基数排序:

是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。基数排序基于分别排序，分别收集，所以是稳定的。

算法实现：

Void RadixSort(Node L[],length,maxradix)  

{  

    int  m,n,k,lsp;  

   k=1;m=1;  

    int  temp[10][length-1];  

   Empty(temp);  //清空临时空间   

    while (k<maxradix)  //遍历所有关键字   

   {  

      for ( int  i=0;i<length;i++)  //分配过程   

    {  

        if (L[i]<m)  

          Temp[0][n]=L[i];  

        else   

          Lsp=(L[i]/m)%10;  //确定关键字   

       Temp[lsp][n]=L[i];  

       n++;  

   }  

   CollectElement(L,Temp);  //收集   

   n=0;  

   m=m*10;  

  k++;  

 }  

}  

3.算法性能及其优化

空间复杂度：O(rd+n)

时间复杂度：最坏 O(d(r+n) )

稳定性：稳定

优化：无