Java 排序算法总结

1. 选择排序

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

举个实例来看看：

初始： [10, 32, 1, 9, 5, 7, 12, 0, 4, 3]

i = 0:  [0 32 1 9 5 7 12 10 4 3] 

i = 1:  [0 1 32 9 5 7 12 10 4 3]

i = 2:  [0 1 3 9 5 7 12 10 4 32]

i = 3:  [0 1 3 4 5 7 12 10 9 32] 

i = 4:  [0 1 3 4 5 7 12 10 9 32]

i = 5:  [0 1 3 4 5 7 12 10 9 32]

i = 6:  [0 1 3 4 5 7 9 10 12 32]

i = 7:  [0 1 3 4 5 7 9 10 12 32] 

i = 8:  [0 1 3 4 5 7 9 10 12 32] 

i = 9:  [0 1 3 4 5 7 9 10 12 32]

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

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

实现代码：
/* 选择排序 ;lz每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。
选择排序是不稳定的排序方法。
*/
public static void doChooseSort(int[] src) {
        int len = src.length;
        int temp;
        for (int i = 0; i < len; i++) {
                temp = src[i];
                int j;
                int samllestLocation = i;// 最小数的下标
                for (j = i + 1; j < len; j++) {
                        if (src[j] < temp) {
                        temp = src[j];// 取出最小值
                        samllestLocation = j;// 取出最小值所在下标
                        }
                }
                // 下面两行代码是将最小数换到最前面
                src[samllestLocation] = src[i];
                src[i] = temp;
                printResult(i, src);
        }
}


2. 插入排序

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

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

初始：    [10, 32, 1, 9, 5, 7, 12, 0, 4, 3]

第一趟： [10 32 1 9 5 7 12 0 4 3]

第二趟： [1 10 32 9 5 7 12 0 4 3] 

第三趟： [1 9 10 32 5 7 12 0 4 3] 

第四趟： [1 5 9 10 32 7 12 0 4 3] 

第五趟： [1 5 7 9 10 32 12 0 4 3]

第六趟： [1 5 7 9 10 12 32 0 4 3]

第七趟： [0 1 5 7 9 10 12 32 4 3]

第八趟： [0 1 4 5 7 9 10 12 32 3] 

第九趟： [0 1 3 4 5 7 9 10 12 32]

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

实现代码：
// 插入排序(WHILE循环实现)
public static void doInsertSort1(int[] src) {
        int len = src.length;
        for (int i = 1; i < len; i++) {
                int temp = src[i];
                int j = i;
                while (src[j - 1] > temp) {
                        src[j] = src[j - 1];
                        j--;
                        if (j <= 0)
                        break;
                }
                src[j] = temp;
                printResult(i, src);
}
}

// 插入排序(FOR循环实现)
// 插入排序就是每一步都将一个待排数据按其大小插入到已经排序的数据中的适当位置，直到全部插入完毕
public static void doInsertSort2(int[] src) {
        int len = src.length;
        for (int i = 1; i < len; i++) {
                int j;
                int temp = src[i];
                for (j = i; j > 0; j--) {
                        if (src[j - 1] > temp) {
                                src[j] = src[j - 1];
                        } else
                        {
                // 如果当前的数，不小前面的数，那就说明不小于前面所有的数，
                // 因为前面已经是排好了序的，所以直接通出当前一轮的比较
                                break;
                        }
                }  
                src[j] = temp;
                printResult(i, src);
        }
}


3. 冒泡排序

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

照例举个简单的实例吧：

初始状态：   [10, 32, 1, 9, 5, 7, 12, 0, 4, 3]

内层第一趟： [10 32 1 9 5 7 12 0 4 3]

内层第二趟： [10 1 32 9 5 7 12 0 4 3]

内层第三趟： [10 1 9 32 5 7 12 0 4 3] 

内层第四趟： [10 1 9 5 32 7 12 0 4 3]

内层第五趟： [10 1 9 5 7 32 12 0 4 3] 

内层第六趟： [10 1 9 5 7 12 32 0 4 3]

内层第七趟： [10 1 9 5 7 12 0 32 4 3] 

内层第八趟： [10 1 9 5 7 12 0 4 32 3] 

内层第九趟： [10 1 9 5 7 12 0 4 3 32]

…...

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

实现代码：

/*
冒泡排序 依次比较相邻的两个数，将小数放在前面，大数放在后面。 即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。
然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后
*/
public static void doBubbleSort(int[] a) {
      int temp;
      boolean hasChange=true;  //用来标记每轮遍历中是否发生了交换

      //每轮遍历开始，将hasChange设置为false
      for (int i = 0; i < a.length - 1 && hasChange; i++) { // -1是因为最后一个没必要再跟它本身比较;hasChange为false的时候可以避免无效循环

          hasChange=false;

          for (int j = 0; j < a.length - i - 1; j++) {
          
                  if (a[j] > a[j + 1])
                   {
                        temp = a[j];
                        a[j] = a[j + 1];
                        a[j + 1] = temp;

                        hasChange=true;
                   }
                   printResult(i, a);
           }
      }
}

// 打印方法
private static void printResult(int i, int[] a) {
          System.out.print("排序中"+(i)+": ");
          for (int j : a)
          {// 和for (int i = 0; i < len; i++) 效果是一样的
                    System.out.print(j + " ");
          }
          System.out.println(" ");
}


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 ，即对整个数组进行插入排序，此时的数组已经基本上快排好序了，所以需要移动的元素会很小很小，解决了插入排序在处理大规模数组时较多移动次数的问题。

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

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

排序前
[10, 32, 1, 9, 5, 7, 12, 0, 4, 3]
排序后
排序中:   5  32   1   9  10   7  12   0   4
排序中:   5   7   1   9  10  32  12   0   4
排序中:   5   7   1   0  10  32  12   9   4
排序中:   4   7   1   0   5  32  12   9  10
排序中:   1   7   4   0   5  32  12   9  10
排序中:   1   0   4   7   5  32  12   9  10
排序中:   1   0   4   7   5   9  12  32  10
排序中:   1   0   4   7   5   9  10  32  12
排序中:   0   1   4   7   5   9  10  32  12
排序中:   0   1   4   5   7   9  10  32  12
排序中:   0   1   4   5   7   9  10  12  32

实现代码：
// shell排序
public static void ShellSort(int Index) {
int i, j, k; // 循环计数变量
int Temp; // 暂存变量
boolean Change; // 数据是否改变
int DataLength; // 分割集合的间隔长度
int Pointer; // 进行处理的位置
DataLength = (int) Index / 2; // 初始集合间隔长度
while (DataLength != 0) // 数列仍可进行分割
{
// 对各个集合进行处理
for (j = DataLength; j < Index; j++) {
Change = false;
Temp = arr[j]; // 暂存Data[j]的值,待交换值时用
Pointer = j - DataLength; // 计算进行处理的位置
// 进行集合内数值的比较与交换值
while (Temp < arr[Pointer] && Pointer >= 0 && Pointer <= Index) {
arr[Pointer + DataLength] = arr[Pointer];
// 计算下一个欲进行处理的位置
Pointer = Pointer - DataLength;
Change = true;
if (Pointer < 0 || Pointer > Index)
break;
}
// 与最后的数值交换
arr[Pointer + DataLength] = Temp;
if (Change) {
// 打印目前排序结果
System.out.print("排序中: ");
for (k = 0; k < Index; k++)
System.out.printf("%3s ", arr[k]);
System.out.println("");
}
}
DataLength = DataLength / 2; // 计算下次分割的间隔长度
}
}


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 的奇偶性的判断），时间复杂度比较难估，这里小弟也忘记是多少了（囧）。

实现代码：

    public void mergeSort(int [] a,int start,int end){
        if(start<end){//当子序列中只有一个元素时结束递归
            int mid=(start+end)/2;//划分子序列
            mergeSort(a, start, mid);//对左侧子序列进行递归排序
            mergeSort(a, mid+1, end);//对右侧子序列进行递归排序
            merge(a, start, mid, end);//合并
        }
    }

    public class MergeSort {

    //两路归并算法，两个排好序的子序列合并为一个子序列
    public void merge(int []a,int left,int mid,int right){
        int []tmp=new int[a.length];//辅助数组
        int p1=left,p2=mid+1,k=left;//p1、p2是检测指针，k是存放指针

        while(p1<=mid && p2<=right){
            if(a[p1]<=a[p2])
                tmp[k++]=a[p1++];
            else
                tmp[k++]=a[p2++];
        }

        while(p1<=mid) tmp[k++]=a[p1++];//如果第一个序列未检测完，直接将后面所有元素加到合并的序列中
        while(p2<=right) tmp[k++]=a[p2++];//同上

        //复制回原素组
        for (int i = left; i <=right; i++)
            a[i]=tmp[i];
    }



    @Test
    public void test(){
        int[] a = { 49, 38, 65, 97, 76, 13, 27, 50 };
        mergeSort(a, 0, a.length-1);
        System.out.println("排好序的数组：");
        for (int e : a)
            System.out.print(e+" ");
    }
}


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]（需要确定位置的为0th[41]）

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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



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

排序前
[10, 32, 1, 9, 5, 7, 12, 0, 4, 3]
排序后
[3, 4, 1, 9, 5, 7, 0, 10, 12, 32]
[0, 1, 3, 9, 5, 7, 4, 10, 12, 32]
[0, 1, 3, 9, 5, 7, 4, 10, 12, 32]
[0, 1, 3, 4, 5, 7, 9, 10, 12, 32]
[0, 1, 3, 4, 5, 7, 9, 10, 12, 32]
[0, 1, 3, 4, 5, 7, 9, 10, 12, 32]
[0, 1, 3, 4, 5, 7, 9, 10, 12, 32]

实现代码：
/**
* 一次排序单元，完成此方法，key左边都比key小，key右边都比key大。
*
* @param array
*            排序数组
* @param low
*            排序起始位置
* @param high
*            排序结束位置
* @return 单元排序后的数组游标
*/
private static int sortUnit(int[] array, int low, int high) {
int key = array[low];
while (low < high) {
// 从后向前搜索比key小的值
while (array[high] >= key && high > low) {
--high;
}
// 比key小的放左边
array[low] = array[high];
// 从前向后搜索比key大的值，比key大的放右边
while (array[low] <= key && high > low) {
++low;
}
// 比key大的放右边
array[high] = array[low];
}
// 左边都比key小，右边都比key大。将key放在游标当前位置。此时low等于high
array[high] = key;
System.out.println(Arrays.toString(array));
return high;
}

//快速排序1
/**
*
* @param
*        array 排序数组
* @param
*        low 排序起始位置
* @param
*        high 排序结束位置
*/
public static void sort(int[] array, int low, int high) {
if (low < high) {
// 完成一次单元排序
int index = sortUnit(array, low, high);
// 对左边单元进行排序
sort(array, low, index - 1);
// 对右边单元进行排序
sort(array, index + 1, high);
}
}

排序前
[10, 32, 1, 9, 5, 7, 12, 0, 4, 3]
排序后
[0, 3, 1, 9, 5, 7, 4, 10, 12, 32]
[0, 3, 1, 9, 5, 7, 4, 10, 12, 32]
[0, 1, 3, 9, 5, 7, 4, 10, 12, 32]
[0, 1, 3, 4, 5, 7, 9, 10, 12, 32]
[0, 1, 3, 4, 5, 7, 9, 10, 12, 32]
[0, 1, 3, 4, 5, 7, 9, 10, 12, 32]
[0, 1, 3, 4, 5, 7, 9, 10, 12, 32]

实现代码：
// 快速排序2
/**
* @param a
*            排序数组
* @param low
*            排序起始位置
* @param high
*            排序结束位置
*/
public static void qSort(int[] a, int p, int r) {
if (p < r) {
int q = partition(a, p, r);
qSort(a, p, q - 1);
qSort(a, q + 1, r);
}
}

/**
*
* @param a
*            排序数组
* @param low
*            排序起始位置
* @param high
*            排序结束位置
* @return
*/
private static int partition(int[] a, int low, int high) {
int i = low, j = high + 1;
int x = a[low];
while (true) {
while (a[++i] < x && i < high); // 找到第一个比 x 大的
while (a[--j] > x); // 找到第一个比 x 小的
if (i >= j)
break;
int temp = a[i];
a[i] = a[j];
a[j] = temp;
}
a[low] = a[j];
a[j] = x;
System.out.println(Arrays.toString(a));
return j;
}