java程序员必知的 8大排序

下载了文档自己截图存留

8种排序之间的关系:

1， 直接插入排序

   （1）基本思想：在要排序的一组数中，假设前面(n-1)[n>=2] 个数已经是排

好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数

也是排好顺序的。如此反复循环，直到全部排好顺序。

 （2）实例

（3）用java实现

 package com.njue;

public class insertSort {
public insertSort(){
    inta[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};
    int temp=0;
    for(int i=1;i<a.length;i++){
       int j=i-1;
       temp=a[i];
       for(;j>=0&&temp<a[j];j--){
       a[j+1]=a[j];                       //将大于temp的值整体后移一个单位
       }
       a[j+1]=temp;
    }
    for(int i=0;i<a.length;i++)
       System.out.println(a[i]);
}
}

2，           希尔排序（最小增量排序）

（1）基本思想：算法先将要排序的一组数按某个增量d（n/2,n为要排序数的个数）分成若干组，每组中记录的下标相差d.对每组中全部元素进行直接插入排序，然后再用一个较小的增量（d/2）对它进行分组，在每组中再进行直接插入排序。当增量减到1时，进行直接插入排序后，排序完成。

（2）实例：

（3）用java实现

public class shellSort {
public  shellSort(){
    int a[]={1,54,6,3,78,34,12,45,56,100};
    double d1=a.length;
    int temp=0;
    while(true){
        d1= Math.ceil(d1/2);
        int d=(int) d1;
        for(int x=0;x<d;x++){
            for(int i=x+d;i<a.length;i+=d){
                int j=i-d;
                temp=a[i];
                for(;j>=0&&temp<a[j];j-=d){
                a[j+d]=a[j];
                }
                a[j+d]=temp;
            }
        }
        if(d==1)
            break;
    }
    for(int i=0;i<a.length;i++)
        System.out.println(a[i]);
}
}

3.简单选择排序

（1）基本思想：在要排序的一组数中，选出最小的一个数与第一个位置的数交换；

然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。

（2）实例：

（3）用java实现

public class selectSort {
    public selectSort(){
        int a[]={1,54,6,3,78,34,12,45};
        int position=0;
        for(int i=0;i<a.length;i++){

            int j=i+1;
            position=i;
            int temp=a[i];
            for(;j<a.length;j++){
            if(a[j]<temp){
                temp=a[j];
                position=j;
            }
            }
            a[position]=a[i];
            a[i]=temp;
        }
        for(int i=0;i<a.length;i++)
            System.out.println(a[i]);
    }
}

4，      堆排序

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

堆的定义如下：具有n个元素的序列（h1,h2,...,hn),当且仅当满足（hi>=h2i,hi>=2i+1）或（hi<=h2i,hi<=2i+1）(i=1,2,...,n/2)时称之为堆。在这里只讨论满足前者条件的堆。由堆的定义可以看出，堆顶元素（即第一个元素）必为最大项（大顶堆）。完全二叉树可以很直观地表示堆的结构。堆顶为根，其它为左子树、右子树。初始时把要排序的数的序列看作是一棵顺序存储的二叉树，调整它们的存储序，使之成为一个堆，这时堆的根节点的数最大。然后将根节点与堆的最后一个节点交换。然后对前面(n-1)个数重新调整使之成为堆。依此类推，直到只有两个节点的堆，并对它们作交换，最后得到有n个节点的有序序列。从算法描述来看，堆排序需要两个过程，一是建立堆，二是堆顶与堆的最后一个元素交换位置。所以堆排序有两个函数组成。一是建堆的渗透函数，二是反复调用渗透函数实现排序的函数。

（2）实例：

初始序列：46,79,56,38,40,84

建堆：

交换，从堆中踢出最大数

依次类推：最后堆中剩余的最后两个结点交换，踢出一个，排序完成。

（3）用java实现

import java.util.Arrays;

public class HeapSort {
     int a[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};
    public  HeapSort(){
        heapSort(a);
    }
    public  void heapSort(int[] a){
        System.out.println("开始排序");
        int arrayLength=a.length;
        //循环建堆
        for(int i=0;i<arrayLength-1;i++){
            //建堆

      buildMaxHeap(a,arrayLength-1-i);
            //交换堆顶和最后一个元素
            swap(a,0,arrayLength-1-i);
            System.out.println(Arrays.toString(a));
        }
    }

    private  void swap(int[] data, int i, int j) {
        // TODO Auto-generated method stub
        int tmp=data[i];
        data[i]=data[j];
        data[j]=tmp;
    }
    //对data数组从0到lastIndex建大顶堆
    private void buildMaxHeap(int[] data, int lastIndex) {
        // TODO Auto-generated method stub
        //从lastIndex处节点（最后一个节点）的父节点开始
        for(int i=(lastIndex-1)/2;i>=0;i--){
            //k保存正在判断的节点
            int k=i;
            //如果当前k节点的子节点存在
            while(k*2+1<=lastIndex){
                //k节点的左子节点的索引
                int biggerIndex=2*k+1;
                //如果biggerIndex小于lastIndex，即biggerIndex+1代表的k节点的右子节点存在
                if(biggerIndex<lastIndex){
                    //若果右子节点的值较大
                    if(data[biggerIndex]<data[biggerIndex+1]){
                        //biggerIndex总是记录较大子节点的索引
                        biggerIndex++;
                    }
                }
                //如果k节点的值小于其较大的子节点的值
                if(data[k]<data[biggerIndex]){
                    //交换他们
                    swap(data,k,biggerIndex);
                    //将biggerIndex赋予k，开始while循环的下一次循环，重新保证k节点的值大于其左右子节点的值
                    k=biggerIndex;
                }else{
                    break;
                }
            }<p align="left"> <span>   </span>}</p><p align="left">    }</p><p align="left"> <span style="background-color: white; ">}</span></p>

5.冒泡排序

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

（2）实例：

（3）用java实现

public class bubbleSort {
public  bubbleSort(){
     int a[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};
    int temp=0;
    for(int i=0;i<a.length-1;i++){
        for(int j=0;j<a.length-1-i;j++){
        if(a[j]>a[j+1]){
            temp=a[j];
            a[j]=a[j+1];
            a[j+1]=temp;
        }
        }
    }
    for(int i=0;i<a.length;i++)
    System.out.println(a[i]);
}
}

6.快速排序

（1）基本思想：选择一个基准元素,通常选择第一个元素或者最后一个元素,通过一趟扫描，将待排序列分成两部分,一部分比基准元素小,一部分大于等于基准元素,此时基准元素在其排好序后的正确位置,然后再用同样的方法递归地排序划分的两部分。

（2）实例：

（3）用java实现

public class quickSort {
  int a[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};
public  quickSort(){
    quick(a);
    for(int i=0;i<a.length;i++)
        System.out.println(a[i]);
}
public int getMiddle(int[] list, int low, int high) {
            int tmp = list[low];    //数组的第一个作为中轴
            while (low < high) {
                while (low < high && list[high] >= tmp) {

      high--;
                }
                list[low] = list[high];   //比中轴小的记录移到低端
                while (low < high && list[low] <= tmp) {
                    low++;
                }
                list[high] = list[low];   //比中轴大的记录移到高端
            }
           list[low] = tmp;              //中轴记录到尾
            return low;                   //返回中轴的位置
        }
public void _quickSort(int[] list, int low, int high) {
            if (low < high) {
               int middle = getMiddle(list, low, high);  //将list数组进行一分为二
                _quickSort(list, low, middle - 1);        //对低字表进行递归排序
               _quickSort(list, middle + 1, high);       //对高字表进行递归排序
            }
        }
public void quick(int[] a2) {
            if (a2.length > 0) {    //查看数组是否为空
                _quickSort(a2, 0, a2.length - 1);
        }
       }
}

7、归并排序

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

（2）实例：

（3）用java实现

import java.util.Arrays;

public class mergingSort {
int a[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};
public  mergingSort(){
    sort(a,0,a.length-1);
    for(int i=0;i<a.length;i++)
        System.out.println(a[i]);
}
public void sort(int[] data, int left, int right) {
    // TODO Auto-generated method stub
    if(left<right){
        //找出中间索引
        int center=(left+right)/2;
        //对左边数组进行递归
        sort(data,left,center);
        //对右边数组进行递归
        sort(data,center+1,right);
        //合并
        merge(data,left,center,right);

    }
}
public void merge(int[] data, int left, int center, int right) {
    // TODO Auto-generated method stub
    int [] tmpArr=new int[data.length];
    int mid=center+1;
    //third记录中间数组的索引
    int third=left;
    int tmp=left;
    while(left<=center&&mid<=right){

   //从两个数组中取出最小的放入中间数组
        if(data[left]<=data[mid]){
            tmpArr[third++]=data[left++];
        }else{
            tmpArr[third++]=data[mid++];
        }
    }
    //剩余部分依次放入中间数组
    while(mid<=right){
        tmpArr[third++]=data[mid++];
    }
    while(left<=center){
        tmpArr[third++]=data[left++];
    }
    //将中间数组中的内容复制回原数组
    while(tmp<=right){
        data[tmp]=tmpArr[tmp++];
    }
    System.out.println(Arrays.toString(data));
}

}

8、基数排序

（1）基本思想：将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后,数列就变成一个有序序列。

（2）实例：

（3）用java实现

import java.util.ArrayList;
import java.util.List;

public class radixSort {
    int a[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,101,56,17,18,23,34,15,35,25,53,51};
public radixSort(){
    sort(a);
    for(int i=0;i<a.length;i++)
        System.out.println(a[i]);
}
public  void sort(int[] array){

            //首先确定排序的趟数;
        int max=array[0];
        for(int i=1;i<array.length;i++){
               if(array[i]>max){
               max=array[i];
               }
            }

    int time=0;
           //判断位数;
            while(max>0){
               max/=10;
                time++;
            }

        //建立10个队列;
            List<ArrayList> queue=new ArrayList<ArrayList>();
            for(int i=0;i<10;i++){
                ArrayList<Integer> queue1=new ArrayList<Integer>();
                queue.add(queue1);
        }

            //进行time次分配和收集;
            for(int i=0;i<time;i++){

                //分配数组元素;
               for(int j=0;j<array.length;j++){
                    //得到数字的第time+1位数;
                   int x=array[j]%(int)Math.pow(10, i+1)/(int)Math.pow(10, i);
                   ArrayList<Integer> queue2=queue.get(x);
                   queue2.add(array[j]);
                   queue.set(x, queue2);
            }
                int count=0;//元素计数器;
            //收集队列元素;
                for(int k=0;k<10;k++){
                while(queue.get(k).size()>0){
                    ArrayList<Integer> queue3=queue.get(k);
                        array[count]=queue3.get(0);
                        queue3.remove(0);
                    count++;
              }
            }
    }
   }

}

常用排序算法小记

排序算法很多地方都会用到，近期又重新看了一遍算法，并自己简单地实现了一遍，特此记录下来，为以后复习留点材料。

废话不多说，下面逐一看看经典的排序算法：

1. 选择排序

选择排序的基本思想是遍历数组的过程中，以 i 代表当前需要排序的序号，则需要在剩余的 [i…n-1] 中找出其中的最小值，然后将找到的最小值与 i 指向的值进行交换。因为每一趟确定元素的过程中都会有一个选择最大值的子流程，所以人们形象地称之为选择排序。

举个实例来看看：

初始： [38, 17, 16, 16, 7, 31, 39, 32, 2, 11]

i = 0:  [2 , 17, 16, 16, 7, 31, 39, 32, 38 , 11] (0^th [38]<->8^th [2])

i = 1:  [2, 7 , 16, 16, 17 , 31, 39, 32, 38, 11] (1^st [38]<->4^th [17])

i = 2:  [2, 7, 11 , 16, 17, 31, 39, 32, 38, 16 ] (2^nd [11]<->9^th [16])

i = 3:  [2, 7, 11, 16, 17, 31, 39, 32, 38, 16] ( 无需交换 )

i = 4:  [2, 7, 11, 16, 16 , 31, 39, 32, 38, 17 ] (4^th [17]<->9^th [16])

i = 5:  [2, 7, 11, 16, 16, 17 , 39, 32, 38, 31 ] (5^th [31]<->9^th [17])

i = 6:  [2, 7, 11, 16, 16, 17, 31 , 32, 38, 39 ] (6^th [39]<->9^th [31])

i = 7:  [2, 7, 11, 16, 16, 17, 31, 32, 38, 39] ( 无需交换 )

i = 8:  [2, 7, 11, 16, 16, 17, 31, 32, 38, 39] ( 无需交换 )

i = 9:  [2, 7, 11, 16, 16, 17, 31, 32, 38, 39] ( 无需交换 )

由例子可以看出，选择排序随着排序的进行（ i 逐渐增大），比较的次数会越来越少，但是不论数组初始是否有序，选择排序都会从 i 至数组末尾进行一次选择比较，所以给定长度的数组，选择排序的比较次数是固定的： 1 + 2 + 3 + …. + n = n * (n + 1) / 2 ，而交换的次数则跟初始数组的顺序有关，如果初始数组顺序为随机，则在最坏情况下，数组元素将会交换 n 次，最好的情况下则可能 0 次（数组本身即为有序）。

由此可以推出，选择排序的时间复杂度和空间复杂度分别为 O(n² ) 和 O(1) （选择排序只需要一个额外空间用于数组元素交换）。

实现代码：

Java代码  

1. /** 
2.  * Selection Sorting 
3.  */  
4. SELECTION(new Sortable() {  
5.     public <T extends Comparable<T>> void sort(T[] array, boolean ascend) {  
6.         int len = array.length;  
7.         for (int i = 0; i < len; i++) {  
8.             int selected = i;  
9.             for (int j = i + 1; j < len; j++) {  
10.                 int compare = array[j].compareTo(array[selected]);  
11.                 if (compare != 0 && compare < 0 == ascend) {  
12.                     selected = j;  
13.                 }  
14.             }  
15.   
16.             exchange(array, i, selected);  
17.         }  
18.     }  
19. })  

2. 插入排序

插入排序的基本思想是在遍历数组的过程中，假设在序号 i 之前的元素即 [0..i-1] 都已经排好序，本趟需要找到 i 对应的元素 x 的正确位置 k ，并且在寻找这个位置 k 的过程中逐个将比较过的元素往后移一位，为元素 x “腾位置”，最后将 k 对应的元素值赋为 x ，插入排序也是根据排序的特性来命名的。

以下是一个实例，红色 标记的数字为插入的数字，被划掉的数字是未参与此次排序的元素，红色 标记的数字与被划掉数字之间的元素为逐个向后移动的元素，比如第二趟参与排序的元素为 [11, 31, 12] ，需要插入的元素为 12 ，但是 12 当前并没有处于正确的位置，于是我们需要依次与前面的元素 31 、 11 做比较，一边比较一边移动比较过的元素，直到找到第一个比 12 小的元素 11 时停止比较，此时 31 对应的索引 1 则是 12 需要插入的位置。

初始：    [11, 31, 12, 5, 34, 30, 26, 38, 36, 18]

第一趟： [11, 31 , 12, 5, 34, 30, 26, 38, 36, 18] （无移动的元素）

第二趟： [11, 12 , 31, 5, 34, 30, 26, 38, 36, 18] （ 31 向后移动）

第三趟： [5 , 11, 12, 31, 34, 30, 26, 38, 36, 18] （ 11, 12, 31 皆向后移动）

第四趟： [5, 11, 12, 31, 34 , 30, 26, 38, 36, 18] （无移动的元素）

第五趟： [5, 11, 12, 30 , 31, 34, 26, 38, 36, 18] （ 31, 34 向后移动）

第六趟： [5, 11, 12, 26 , 30, 31, 34, 38, 36, 18] （ 30, 31, 34 向后移动）

第七趟： [5, 11, 12, 26, 30, 31, 34, 38 , 36, 18] （无移动的元素）

第八趟： [5, 11, 12, 26, 30, 31, 34, 36 , 38, 18] （ 38 向后移动）

第九趟： [5, 11, 12, 18 , 26, 30, 31, 34, 36, 38] （ 26, 30, 31, 34, 36, 38 向后移动）

插入排序会优于选择排序，理由是它在排序过程中能够利用前部分数组元素已经排好序的一个优势，有效地减少一些比较的次数，当然这种优势得看数组的初始顺序如何，最坏的情况下（给定的数组恰好为倒序）插入排序需要比较和移动的次数将会等于 1 + 2 + 3… + n = n * (n + 1) / 2 ，这种极端情况下，插入排序的效率甚至比选择排序更差。因此插入排序是一个不稳定的排序方法，插入效率与数组初始顺序息息相关。一般情况下，插入排序的时间复杂度和空间复杂度分别为 O(n² ) 和 O(1) 。

实现代码：

Java代码  

1. /** 
2.  * Insertion Sorting 
3.  */  
4. INSERTION(new Sortable() {  
5.     public <T extends Comparable<T>> void sort(T[] array, boolean ascend) {  
6.         int len = array.length;  
7.         for (int i = 1; i < len; i++) {  
8.             T toInsert = array[i];  
9.             int j = i;  
10.             for (; j > 0; j--) {  
11.                 int compare = array[j - 1].compareTo(toInsert);  
12.                 if (compare == 0 || compare < 0 == ascend) {  
13.                     break;  
14.                 }  
15.                 array[j] = array[j - 1];  
16.             }  
17.   
18.             array[j] = toInsert;  
19.         }  
20.     }  
21. })  

3. 冒泡排序

冒泡排序可以算是最经典的排序算法了，记得小弟上学时最先接触的也就是这个算法了，因为实现方法最简单，两层 for 循环，里层循环中判断相邻两个元素是否逆序，是的话将两个元素交换，外层循环一次，就能将数组中剩下的元素中最小的元素“浮”到最前面，所以称之为冒泡排序。

照例举个简单的实例吧：

初始状态：   [24, 19, 26, 39, 36, 7, 31, 29, 38, 23]

内层第一趟： [24, 19, 26, 39, 36, 7, 31, 29, 23 , 38 ] （ 9^th [23]<->8^th [38 ）

内层第二趟： [24, 19, 26, 39, 36, 7, 31, 23 , 29 , 38] （ 8^th [23]<->7^th [29] ）

内层第三趟： [24, 19, 26, 39, 36, 7, 23 , 31 , 29, 38] （ 7^th [23]<->6^th [31] ）

内层第四趟： [24, 19, 26, 39, 36, 7, 23, 31, 29, 38] （ 7 、 23 都位于正确的顺序，无需交换）

内层第五趟： [24, 19, 26, 39, 7 , 36 , 23, 31, 29, 38] （ 5^th [7]<->4^th [36] ）

内层第六趟： [24, 19, 26, 7 , 39 , 36, 23, 31, 29, 38] （ 4^th [7]<->3^rd [39] ）

内层第七趟： [24, 19, 7 , 26 , 39, 36, 23, 31, 29, 38] （ 3^rd [7]<->2^nd [26] ）

内层第八趟： [24, 7 , 19 , 26, 39, 36, 23, 31, 29, 38] （ 2^nd [7]<->1^st [19] ）

内层第九趟： [7 , 24 , 19, 26, 39, 36, 23, 31, 29, 38] （ 1^st [7]<->0^th [24] ）

…...

其实冒泡排序跟选择排序比较相像，比较次数一样，都为 n * (n + 1) / 2 ，但是冒泡排序在挑选最小值的过程中会进行额外的交换（冒泡排序在排序中只要发现相邻元素的顺序不对就会进行交换，与之对应的是选择排序，只会在内层循环比较结束之后根据情况决定是否进行交换），所以在我看来，选择排序属于冒泡排序的改进版。

实现代码：

Java代码  

1. /** 
2.  * Bubble Sorting, it's very similar with Insertion Sorting 
3.  */  
4. BUBBLE(new Sortable() {  
5.     public <T extends Comparable<T>> void sort(T[] array, boolean ascend) {  
6.         int length = array.length;  
7.         int lastExchangedIdx = 0;  
8.         for (int i = 0; i < length; i++) {  
9.             // mark the flag to identity whether exchange happened to false  
10.             boolean isExchanged = false;  
11.             // last compare and exchange happened before reaching index i  
12.             int currOrderedIdx = lastExchangedIdx > i ? lastExchangedIdx : i;  
13.             for (int j = length - 1; j > currOrderedIdx; j--) {  
14.                 int compare = array[j - 1].compareTo(array[j]);  
15.                 if (compare != 0 && compare > 0 == ascend) {  
16.                     exchange(array, j - 1, j);  
17.                     isExchanged = true;  
18.                     lastExchangedIdx = j;  
19.                 }  
20.             }  
21.             // if no exchange happen means array is already in order  
22.             if (isExchanged == false) {  
23.                 break;  
24.             }  
25.         }  
26.     }  
27. })  

4. 希尔排序

希尔排序的诞生是由于插入排序在处理大规模数组的时候会遇到需要移动太多元素的问题。希尔排序的思想是将一个大的数组“分而治之”，划分为若干个小的数组，以 gap 来划分，比如数组 [1, 2, 3, 4, 5, 6, 7, 8] ，如果以 gap = 2 来划分，可以分为 [1, 3, 5, 7] 和 [2, 4, 6, 8] 两个数组（对应的，如 gap = 3 ，则划分的数组为： [1, 4, 7] 、 [2, 5, 8] 、 [3, 6] ）然后分别对划分出来的数组进行插入排序，待各个子数组排序完毕之后再减小 gap 值重复进行之前的步骤，直至 gap = 1 ，即对整个数组进行插入排序，此时的数组已经基本上快排好序了，所以需要移动的元素会很小很小，解决了插入排序在处理大规模数组时较多移动次数的问题。

具体实例请参照插入排序。

希尔排序是插入排序的改进版，在数据量大的时候对效率的提升帮助很大，数据量小的时候建议直接使用插入排序就好了。

实现代码：

Java代码  

1. /** 
2.  * Shell Sorting 
3.  */  
4. SHELL(new Sortable() {  
5.     public <T extends Comparable<T>> void sort(T[] array, boolean ascend) {  
6.         int length = array.length;  
7.         int gap = 1;  
8.   
9.         // use the most next to length / 3 as the first gap  
10.         while (gap < length / 3) {  
11.             gap = gap * 3 + 1;  
12.         }  
13.   
14.         while (gap >= 1) {  
15.             for (int i = gap; i < length; i++) {  
16.                 T next = array[i];  
17.                 int j = i;  
18.                 while (j >= gap) {  
19.                     int compare = array[j - gap].compareTo(next);  
20.                     // already find its position  
21.                     if (compare == 0 || compare < 0 == ascend) {  
22.                         break;  
23.                     }  
24.   
25.                     array[j] = array[j - gap];  
26.                     j -= gap;  
27.                 }  
28.                 if (j != i) {  
29.                     array[j] = next;  
30.                 }  
31.             }  
32.             gap /= 3;  
33.         }  
34.   
35.     }  
36. })  

5. 归并排序

归并排序采用的是递归来实现，属于“分而治之”，将目标数组从中间一分为二，之后分别对这两个数组进行排序，排序完毕之后再将排好序的两个数组“归并”到一起，归并排序最重要的也就是这个“归并”的过程，归并的过程中需要额外的跟需要归并的两个数组长度一致的空间，比如需要规定的数组分别为： [3, 6, 8, 11] 和 [1, 3, 12, 15] （虽然逻辑上被划为为两个数组，但实际上这些元素还是位于原来数组中的，只是通过一些 index 将其划分成两个数组，原数组为 [3, 6, 8, 11, 1, 3, 12, 15 ，我们设置三个指针 lo, mid, high 分别为 0,3,7 就可以实现逻辑上的子数组划分）那么需要的额外数组的长度为 4 + 4 = 8 。归并的过程可以简要地概括为如下：

1） 将两个子数组中的元素复制到新数组 copiedArray 中，以前面提到的例子为例，则 copiedArray = [3, 6, 8, 11, 1, 3, 12, 15] ；

2） 设置两个指针分别指向原子数组中对应的第一个元素，假定这两个指针取名为 leftIdx 和 rightIdx ，则 leftIdx = 0 （对应 copiedArray 中的第一个元素 [3] ）， rightIdx = 4 （对应 copiedArray 中的第五个元素 [1] ）；

3） 比较 leftIdx 和 rightIdx 指向的数组元素值，选取其中较小的一个并将其值赋给原数组中对应的位置 i ，赋值完毕后分别对参与赋值的这两个索引做自增 1 操作，如果 leftIdx 或 rigthIdx 值已经达到对应数组的末尾，则余下只需要将剩下数组的元素按顺序 copy 到余下的位置即可。

下面给个归并的具体实例：

第一趟：

辅助数组 [21 , 28, 39 | 35, 38] （数组被拆分为左右两个子数组，以 | 分隔开）

[21 ,  ,  ,  ,  ] （第一次 21 与 35 比较 , 左边子数组胜出， leftIdx = 0 ， i = 0 ）

第二趟：

辅助数组 [21, 28 , 39 | 35, 38]

[21 , 28,  ,  ,  ] （第二次 28 与 35 比较，左边子数组胜出， leftIdx = 1 ， i = 1 ）

第三趟： [21, 28, 39 | 35 , 38]

 [21 , 28 , 35,  ,  ] （第三次 39 与 35 比较，右边子数组胜出， rightIdx = 0 ， i = 2 ）

第四趟： [21, 28, 39 | 35, 38 ]

 [21 , 28 , 35 , 38,  ] （第四次 39 与 38 比较，右边子数组胜出， rightIdx = 1 ， i = 3 ）

第五趟： [21, 28, 39 | 35, 38]

 [21 , 28 , 35 , 38 , 39] （第五次时右边子数组已复制完，无需比较 leftIdx = 2 ， i = 4 ）

以上便是一次归并的过程，我们可以将整个需要排序的数组做有限次拆分（每次一分为二）直到分为长度为1 的小数组为止，长度为 1 时数组已经不用排序了。在这之后再逆序（由于采用递归）依次对这些数组进行归并操作，直到最后一次归并长度为 n / 2 的子数组，归并完成之后数组排序也完成。

归并排序需要的额外空间是所有排序中最多的，每次归并需要与参与归并的两个数组长度之和相同个元素（为了提供辅助数组）。则可以推断归并排序的空间复杂度为 1 + 2 + 4 + … + n = n * ( n + 2) / 4 （忽略了 n 的奇偶性的判断），时间复杂度比较难估，这里小弟也忘记是多少了（囧）。

实现代码：

Java代码  

1. /** 
2.  * Merge sorting 
3.  */  
4. MERGE(new Sortable() {  
5.     public <T extends Comparable<T>> void sort(T[] array, boolean ascend) {  
6.         this.sort(array, 0, array.length - 1, ascend);  
7.     }  
8.   
9.     private <T extends Comparable<T>> void sort(T[] array, int lo, int hi, boolean ascend) {  
10.         // OPTIMIZE ONE  
11.         // if the substring's length is less than 20,  
12.         // use insertion sort to reduce recursive invocation  
13.         if (hi - lo < 20) {  
14.             for (int i = lo + 1; i <= hi; i++) {  
15.                 T toInsert = array[i];  
16.                 int j = i;  
17.                 for (; j > lo; j--) {  
18.                     int compare = array[j - 1].compareTo(toInsert);  
19.                     if (compare == 0 || compare < 0 == ascend) {  
20.                         break;  
21.                     }  
22.                     array[j] = array[j - 1];  
23.                 }  
24.   
25.                 array[j] = toInsert;  
26.             }  
27.   
28.             return;  
29.         }  
30.   
31.         int mid = lo + (hi - lo) / 2;  
32.         sort(array, lo, mid, ascend);  
33.         sort(array, mid + 1, hi, ascend);  
34.         merge(array, lo, mid, hi, ascend);  
35.     }  
36.   
37.     private <T extends Comparable<T>> void merge(T[] array, int lo, int mid, int hi, boolean ascend) {  
38.         // OPTIMIZE TWO  
39.         // if it is already in right order, skip this merge  
40.         // since there's no need to do so  
41.         int leftEndCompareToRigthStart = array[mid].compareTo(array[mid + 1]);  
42.         if (leftEndCompareToRigthStart == 0 || leftEndCompareToRigthStart < 0 == ascend) {  
43.             return;  
44.         }  
45.   
46.         @SuppressWarnings("unchecked")  
47.         T[] arrayCopy = (T[]) new Comparable[hi - lo + 1];  
48.         System.arraycopy(array, lo, arrayCopy, 0, arrayCopy.length);  
49.   
50.         int lowIdx = 0;  
51.         int highIdx = mid - lo + 1;  
52.   
53.         for (int i = lo; i <= hi; i++) {  
54.             if (lowIdx > mid - lo) {  
55.                 // left sub array exhausted  
56.                 array[i] = arrayCopy[highIdx++];  
57.             } else if (highIdx > hi - lo) {  
58.                 // right sub array exhausted  
59.                 array[i] = arrayCopy[lowIdx++];  
60.             } else if (arrayCopy[lowIdx].compareTo(arrayCopy[highIdx]) < 0 == ascend) {  
61.                 array[i] = arrayCopy[lowIdx++];  
62.             } else {  
63.                 array[i] = arrayCopy[highIdx++];  
64.             }  
65.         }  
66.     }  
67. })  

6. 快速排序

快速排序也是用归并方法实现的一个“分而治之”的排序算法，它的魅力之处在于它能在每次partition（排序算法的核心所在）都能为一个数组元素确定其排序最终正确位置（一次就定位准，下次循环就不考虑这个元素了）。

快速排序的partition操作按以下逻辑进行，假定本次排序的数组为arr：

1） 选择一个元素（为了简单起见，就选择本次partition的第一个元素，即arr[0]）作为基准元素，接下来的步骤会为其确定排序完成后最终的位置；

2） 1）  接下来需要遍历[1…n-1]对应的数组元素以帮助找到arr[0]值（以v替代）对应的位置，定义i为当前访问数组的索引，lt为值小于v的最大索引，gt为值大于v的最小索引，那么在遍历过程中，如果发现i指向的值与v相等，则将i值加1，继续下一次比较；如果i指向的值比v小，则将i和lt对应的元素进行交换，然后分别将两个索引加1；如果i指向的值比v大，则将i与gt对应的元素进行交换，然后i自增，gt自减。循环遍历完成（i > gt时结束）之后可以保证[0…lt-1]对应的值都是比v小的，[lt..gt]之间的值都是与v相等的，[gt+1…n-1]对应的值都是比v大的。

3） 分别对[0…lt-1]和[gt+1…n-1]两个子数组进行排序，如此递归，直至子子子数组的长度为0。

下面举个partition的具体实例：

初始（i = 1, lt = 0, gt = 8）：

       [41, 59, 43, 26, 63, 30, 29, 26, 42]（需要确定位置的为0^th[41]）

第一趟（i = 1, lt = 0, gt = 8）：

       [41, 42, 43, 26, 63, 30, 29, 26, 59]（1^st[59] > 41，1^st[59]<->8^th[42]，gt--）

第二趟（i = 1, lt = 0, gt = 7）：

       [41, 26, 43, 26, 63, 30, 29, 42, 59]（1^st[42] > 41，1^st[42]<->7^th[26]，gt--）

第三趟（i = 1, lt = 0, gt = 6）：

       [26, 41, 43, 26, 63, 30, 29, 42, 59]（1^st[26] < 41, 1^st[26]<->0^st[41]，i++, lt++）

第四趟（i = 2, lt = 1, gt = 6）：

       [26, 41, 29, 26, 63, 30, 43, 42, 59]（2^nd[43] > 41，2^nd[43]<->6^th[29]，gt--）

第五趟（i = 2, lt = 1, gt = 5）：

       [26, 29, 41, 26, 63, 30, 43, 42, 59]（2^nd[29] < 41, 2^nd[29]<->1^st[41]，i++，lt++）

第六趟（i = 3, lt = 2, gt = 5）：    

       [26, 29, 26, 41, 63, 30, 43, 42, 59]（3^rd[26] < 41，3^rd[26]<->2^nd[41]，i++，lt++）

第七趟（i = 4, lt = 3, gt = 5）：

       [26, 29, 26, 41, 30, 63, 43, 42, 59] （4^th[63] > 41，4^th[63]<->5^th[30]，gt--）

第八趟（i = 4, lt = 3, gt = 4）：    

       [26, 29, 26, 30, 41, 63, 43, 42, 59]（4^th[30] < 41，4^th[30]<->3^rd[41]，i++，lt++）

可以看出，在一次partition之后，以41为分割线，41左侧皆为比它小的元素，41右侧皆为比它大或相等的元素（当然这个实例比较特殊，没有出现和41相等的元素）。快速排序顾名思义就是排序速度非常快，后面我会放在我机器上跑各个排序方法的时间对比图。值得一提的是JDK中在Arrays工具内中内置的sort方法就是接合插入排序和三路快速排序实现的，有兴趣的同学可以看看JDK的源码。

实现代码：

Java代码  

1. /** 
2.  * Quick Sorting 
3.  */  
4. QUICK(new Sortable() {  
5.     public <T extends Comparable<T>> void sort(T[] array, boolean ascend) {  
6.         this.sort(array, 0, array.length - 1, ascend);  
7.     }  
8.   
9.     private <T extends Comparable<T>> void sort(T[] array, int lo, int hi, boolean ascend) {  
10.         if (lo >= hi) {  
11.             return;  
12.         }  
13.   
14.         T toFinal = array[lo];  
15.         int leftIdx = lo;  
16.         int rightIdx = hi;  
17.   
18.         int i = lo + 1;  
19.   
20.         while (i <= rightIdx) {  
21.             int compare = array[i].compareTo(toFinal);  
22.             if (compare == 0) {  
23.                 i++;  
24.             } else if (compare < 0 == ascend) {  
25.                 exchange(array, leftIdx++, i++);  
26.             } else {  
27.                 exchange(array, rightIdx--, i);  
28.             }  
29.         }  
30.   
31.         // partially sort left array and right array  
32.         // no need to include the leftIdx-th to rightIdx-th elements  
33.         // since they are already in its final position  
34.         sort(array, lo, leftIdx - 1, ascend);  
35.         sort(array, rightIdx + 1, hi, ascend);  
36.     }  
37. })  

如果你希望查看完整代码，请移驾至我的GoogleCode查看，传送门。

这里是我测试时的测试用例，利用了枚举和策略模式的优势，切换排序算法时相对会比较容易。

以下为经典排序算法在我机器上运行的耗时对比图（测试用的随机数组长度为50000），直接截的测试用例的图。

 鉴于有博友提到无法访问GoogleCode,我将项目工程以附件的方式上传了,需要的博友请下载吧.

• SortMethods.zip (194.1 KB)
• 下载次数: 372