常用的八种排序算法的原理实现及其比较（JAVA实现）

首先说明一个概念问题，排序的稳定性问题。如果Ai = Aj，排序前Ai在Aj之前，排序后Ai还在Aj之前，则称这种排序算法是稳定的，否则说明该算法不稳定。
我们这里说说八大排序就是内部排序。



        当n较大，则应采用时间复杂度为O(nlog2n)的排序方法：快速排序、堆排序或归并排序序。   快速排序：是目前基于比较的内部排序中被认为是最好的方法，当待排序的关键字是随机分布时，快速排序的平均时间最短；常用的排序算法的时间复杂度和空间复杂度

排序法	最差时间分析	平均时间复杂度	稳定度	空间复杂度
冒泡排序	O(n2)	O(n2)	稳定	O(1)
插入排序	O(n2)	O(n2)	稳定	O(1)
选择排序	O(n2)	O(n2)	稳定	O(1)
二叉树排序	O(n2)	O(n*log2n)	不一顶	O(n)
快速排序	O(n2)	O(n*log2n)	不稳定	O(log2n)~O(n)
堆排序	O(n*log2n)	O(n*log2n)	不稳定	O(1)
希尔排序	O	O	不稳定	O(1)

直接插入排序：
        基本思想：在要排序的一组数中，假设前面(n-1) [n>=2] 个数已经是排好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数也是排好顺序的。如此反复循环，直到全部排好顺序。



public void insertSort(int[] array){
int len=array.length;
int numtoinsert;
int j;
for(int i=1;i<len;i++){
numtoinsert=array[i];
//把i之前大于array[i]的数往后移一位
for(j=i-1;j>=0&&array[j]>numtoinsert;j--) {
array[j + 1] = array[j];
}
array[j+1]=numtoinsert;
}
}    该算法为稳定算法，空间复杂度为O(1)，最好的情况是所有元素都是有序的，比较次数为n-1，最坏的情况是所有元素都是逆序，比较次数为(n+2)(n-1)/2，所以该算法的平均时间复杂度为O(n^2)。

二分折半插入排序

    基于直接插入排序，完全可以采用二分查找的方式找到合适的位置再进行插入，这显然要比直接插入效率更高。

public void InsertSort(int [] array){
int len=array.length;
int mid,low,high;
int key;
for(int i=1;i<len;i++){
key=array[i];
low=0;high=i-1;
while(low<=high){
mid=(low+high)/2;
if(array[mid]==key)
break;
else if(key>array[mid]){
low=mid+1;
}else{
high=mid-1;
}
}
//low的索引位置就是即将要插入的位置
//移动low索引位置后面的元素
for(int j=i-1;j>=low;j--){
array[j+1]=array[j];
}
array[low]=key;
}
}

    虽然折半插入改善了查找插入位置的比较次数，但是移动的时间耗费没有得到改善，时间复杂度仍为O(n^2)。

希尔排序
    直接插入排序在整个待排序列基本有序的情况下，效率最佳，但我们往往不能保证每次排序的序列都是基本有序地。希尔排序就是基于这样的情况，它将待排序列拆分成多个子序列，保证每个字序列的
4000
组成元素相对较少，然后通过对子序列使用直接插入排序。对于本就容量不大的子序列来说，直接插入排序的效率是相当优秀的。
基本思想：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。操作方法：

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


算法实现：我们简单处理增量序列：增量序列d = {n/2 ,n/4, n/8 .....1} n为要排序数的个数
即：先将要排序的一组记录按某个增量d（n/2,n为要排序数的个数）分成若干组子序列，每组中记录的下标相差d.对每组中全部元素进行直接插入排序，然后再用一个较小的增量（d/2）对它进行分组，在每组中再进行直接插入排序。继续不断缩小增量直至为1，最后使用直接插入排序完成排序。public void shellSort(int [] array){
int len=array.length;
while(len!=0){
len=len/2;
for(int i=0;i<len;i++){ //分组,有len组
for(int j=i+len;j<array.length;j++){
int k;
int temp=array[j];
for(k=j-len;k>=0&&array[k]>temp;k-=len){
array[k+len]=array[k];
}
array[k+len]=temp;
}
}
}
}
简单选择排序
在要排序的一组数中，选出最小（或者最大）的一个数与第1个位置的数交换；然后在剩下的数当中再找最小（或者最大）的与第2个位置的数交换，依次类推，直到第n-1个元素（倒数第二个数）和第n个元素（最后一个数）比较为止。简单选择排序的示例：
 

操作方法：第一趟，从n 个记录中找出关键码最小的记录与第一个记录交换；第二趟，从第二个记录开始的n-1 个记录中再选出关键码最小的记录与第二个记录交换；以此类推.....
第i 趟，则从第i 个记录开始的n-i+1 个记录中选出关键码最小的记录与第i 个记录交换，直到整个序列按关键码有序。

import java.util.Arrays;

public class SimpleSelectionSort {
//简单选择排序
public void SelectSort(int [] array){
int len=array.length;
for(int i=0;i<len;i++){
int minIndex=selectMin(array,i);
if(i!=minIndex){
int temp=array[i];
array[i]=array[minIndex];
array[minIndex]=temp;
}
}

}

public int selectMin(int[] array,int i){
int k=i;
for(int j=i+1;j<array.length;j++){
if(array[j]<array[k])
k=j;
}
return k;
}

public static void main(String[] args) {
SimpleSelectionSort s=new SimpleSelectionSort();
int[] array={32,43,23,13,5,19,34,42,10,4};
s.SelectSort(array);
System.out.println(Arrays.toString(array));
}
}

快速排序（交换排序）
基本思想：1）选择一个基准元素,通常选择第一个元素或者最后一个元素,2）通过一趟排序将待排序的记录分割成独立的两部分，其中一部分记录的元素值均比基准元素值小。另一部分记录的元素值比基准值大。3）此时基准元素在其排好序后的正确位置4）然后分别对这两部分记录用同样的方法继续进行排序，直到整个序列有序。快速排序的示例：（a）一趟排序的过程：


（b）排序的全过程



算法的实现：import java.util.Arrays;

public class QuickSort {
public int partition(int[] a,int low,int high){
int privokey=a[low];
while(low<high){
while(low<high && a[high]>=privokey)
--high;
swap(a,low,high);
while(low<high && a[low]<=privokey)
++low;
swap(a,low,high);
}
return low;
}

public void QuickSort(int[] a,int low,int high){
if(low<high){
int privocLoc=partition(a,low,high);
QuickSort(a,0,privocLoc-1);
QuickSort(a,privocLoc+1,high);
}
}

public void swap(int[] a,int i,int j){
int temp=a[i];
a[i]=a[j];
a[j]=temp;
}

public static void main(String[] args) {
QuickSort q=new QuickSort();
int[] array={32,43,23,13,5,19,34,42,10,4};
q.QuickSort(array,0,array.length-1);
System.out.println(Arrays.toString(array));
}
}
堆排序
堆排序是一种树形选择排序，是对直接选择排序的有效改进。
基本思想：堆的定义如下：具有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）
                              


                              


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

public class HeapSort {
//大根堆排序算法
public void Heapsort(int[] array,int length){
//初始堆
BuildHeap(array,length);
for(int i=length-1;i>=0;i--){
//交换堆顶元素array[0]和堆中最后一个元素
in
deb2
t temp=array[i];
array[i]=array[0];
array[0]=temp;
//交换之后，重新调整堆
AdjustHeap(array,0,i);
}
}

/**
* 初始堆进行调整
* 将H[0..length-1]建成堆
* 调整完之后第一个元素是序列的最大的元素
*/
public void BuildHeap(int[] array,int length){
//(length-1)/2为最后一个有孩子结点的位置
for(int i=(length-1)/2;i>=0;i--){
AdjustHeap(array,i,length);
}
}

//调整array[s],使其成为大顶堆.即将对第s个结点为根的子树筛选
public void AdjustHeap(int[] array,int s,int length){ //从上往下调整
int temp=array[s];
int child=2*s+1; //左孩子结点位置
while(child<length){
//如果右孩子大于左孩子(找到比当前待调整结点大的孩子结点)
if(child+1<length && array[child+1]>array[child]){
++child;
}
if(array[s]<array[child]){
array[s]=array[child]; //先把较大的子节点往上移，替换父结点
array[child]=temp; //互换s和child元素
s=child; //重新调整s，即为待调整的下一节点
child=s*2+1; //待调整新的s的左孩子结点
}else {
break;
}
}
}

public static void main(String[] args) {
HeapSort heapSort=new HeapSort();
int[] array={32,43,23,13,5,19,34,42,10,4};
heapSort.Heapsort(array,array.length);
System.out.println(Arrays.toString(array));
}
}
结果：



分析:
设树深度为k，

。从根到叶的筛选，元素比较次数至多2(k-1)次，交换记录至多k 次。所以，在建好堆后，排序过程中的筛选次数不超过下式：                                 


而建堆时的比较次数不超过4n 次，因此堆排序最坏情况下，时间复杂度也为：O(nlogn )。
冒泡排序（交换排序）
基本思想：在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。冒泡排序的示例： 

算法的实现：public void bubblesort(int[] array){
int len=array.length;
for(int i=0;i<len-1;i++){
for(int j=0;j<len-i-1;j++) {
if (array[j] > array[j+1]) {
int temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
}
}冒泡排序算法的改进对冒泡排序常见的改进方法是加入一标志性变量exchange，用于标志某一趟排序过程中是否有数据交换，如果进行某一趟排序时并没有进行数据交换，则说明数据已经按要求排列好，可立即结束排序，避免不必要的比较过程。本文再提供以下两种改进算法：1．设置一标志性变量pos,用于记录每趟排序中最后一次进行交换的位置。由于pos位置之后的记录均已交换到位,故在进行下一趟排序时只要扫描到pos位置即可。改进后算法如下:public void bubblesort1(int[] array){
int len=array.length;
int i=len-1; //初始时，最后位置保持不变
while (i>0){
int pos=0; //每趟开始的时候，无记录交换
for(int j=0;j<i;j++){
if(array[j]>array[j+1]){
pos=j; //记录交换的位置
int temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
i=pos; //pos为最后交换的位置
}
}2．传统冒泡排序中每一趟排序操作只能找到一个最大值或最小值,我们考虑利用在每趟排序中进行正向和反向两遍冒泡的方法一次可以得到两个最终值(最大者和最小者) , 从而使排序趟数几乎减少了一半。改进后的算法实现为:public void bubblesort2(int[] array){
int len=array.length;
int low=0;
int high=len-1;
int j;
while(low<high){
for(j=low;j<high;j++){ //正向冒泡，找到最大值
if(array[j]>array[j+1]){
int temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
--high;
for(j=high;j>low;j--){ //反向冒泡，找到最小值
if(array[j]<array[j-1]){
int temp = array[j];
array[j] = array[j - 1];
array[j - 1] = temp;
}
}
++low;
}
}归并排序
基本思想：

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

归并排序示例： 

归并排序的核心思想是，对于一个初始的序列不断递归，直到子序列中的元素足够少时，对他们进行直接排序。然后递归返回继续对两个分别有序的序列进行直接排序，最终递归结束的时候，整个序列必然是有序的。

对于一个初始序列，我们递归拆分的结果如上图。最小的子序列只有两个元素，我们可以轻易的对他们进行直接的排序。简单的排序结果如下：

然后我们递归返回：

初看起来和我们的希尔排序的基本思想有点像，希尔排序通过对初始序列的稀疏化，使得每个子序列在内部上都是有序的，最终在对整个序列进行排序的时候，序列的内部基本有序，总体上能提高效率。但是我们的归并排序的和核心思想是，通过不断的递归，直到子序列元素足够少，在内部对他们进行直接的排序操作，当递归返回的时候，对返回的两个子表再次进行归并排序，使得合成的新序列是有序的，一直到递归返回调用结束时候，整个序列就是有序的。import java.util.Arrays;

public class MergeSort {
public void mergesort(int[] array,int low,int high){
if(low==high){
return;
}else{
int mid=(low+high)/2;
mergesort(array,low,mid);
mergesort(array,mid+1,high);
//相邻两个子集和的归并
MergeTwoData(array,low,mid,high);
//MergeTwoData(array,low,high);
}
}
//写法一：
public void MergeTwoData(int[] array,int low,int mid,int high){
int[] arrcopy=new int[high-low+1]; //辅助数组
int i=low;int m=mid;
int j=mid+1; int n=high; //i指针指向前一个数组的头指针，j指针指向后一个数组的头指针
int index=0;
while(i<=m &&j<=n){ //两个数组都还没到头
if(array[i]>array[j]){
arrcopy[index++]=array[j];
j++;
}else{
arrcopy[index++]=array[i];
i++;
}
}
while(i<=m)
arrcopy[index++]=array[i++];
while(j<=n)
arrcopy[index++]=array[j++];

//写回原数组
int k=0;
for(int o=low;o<=high;o++){
array[o]=arrcopy[k++];
}
}
//写法二：
public void MergeTwoData(int[] array,int low,int high){
int[] arrcopy=new int[high-low+1]; //辅助数组
int i,j;
i=low;j=(low+high)/2+1; //i指针指向前一个数组的头指针，j指针指向后一个数组的头指针
for(int key=0;key<high-low+1;key++){ //也可以使用直接插入排序，时间复杂度更高。这里利用空间换时间
//左侧数组指针指向右侧数组开头，说明左侧数组到头，直接把右侧数组剩下的数放入辅助数组即可
if(i==(low+high)/2+1){
arrcopy[key]=array[j];
j++;
}
//右侧指针指向尽头的下一个位置，说明右侧数组到头，直接把左侧数组剩下的数放入辅助数组即可
else if(j==high+1){
arrcopy[key]=array[i];
i++;
}else if(array[i]<array[j]){ //左侧数组指针的数小于右侧数组指针的数
arrcopy[key]=array[i];
i++;
}else{ //右侧数组指针的数小于左侧数组指针的数
arrcopy[key]=array[j];
j++;
}
}
//写回原数组
int index=0;
for(int o=low;o<=high;o++){
array[o]=arrcopy[index];
index++;
}
}
public static void main(String[] args) {
MergeSort mergeSort=new MergeSort();
int[] array={32,43,23,13,5,19,34,42,10,4};
// int[] array={1,2,3,4,5,6,7,0};
mergeSort.mergesort(array,0,array.length-1);
System.out.println(Arrays.toString(array));
}
}