排序1：常见排序方法的简单介绍

虽然时间复杂度不是考察一个算法的唯一指标，但却是大部分情况下都非常看重的，所以我们就按这个思路梳理一下常见的排序算法。
常见的排序算法按照时间复杂度可划分成两类，

1. O(n²)：插入排序、选择排序。
2. O(nlogn)：归并排序、快速排序。

比较简单的排序方法

虽然从统计意义上，O(n²)的排序算法要比O(nlogn)排序算法慢很多，但它易于实现，并且在某些特殊场景下非常高效，因此会作为一些复杂算法的子过程。更重要的是，这是我们学习排序的开端，也是向复杂排序算法的演进的开始。
简单来讲，选择排序是选择后方无序数组[i, n-1]中最小的，放在第i位；插入排序是将第i位元素，插入前方有序数组[0, i-1]。

选择排序

选择排序是原地、不稳定的排序算法，其时间复杂度为O(n²)，空间复杂度为O(1)。

public class SelectionSort {
    private SelectionSort(){}
    public static <T extends Comparable<T>> T[] sort(T[] arr){
        int n = arr.length;
        for(int i=0; i<n; i++){
            int minIndex = i;
            for (int j=i; j<n; j++) {
                if (arr[j].compareTo(arr[minIndex]) < 0) {
                    arr = SortHelper.swap(minIndex, j, arr);
                }
            }
        }
        return arr;
    }
}

注：SortHelper类请见本文末尾。

插入排序

插入排序是原地、稳定的排序算法，平均时间复杂度为O(n²)，最好情况的时间复杂度为O(n)，空间复杂度为O(1)。对于近乎有序的数组，效率非常高，因此常作为一些复杂算法的子过程。

public class InsertionSort {
    private InsertionSort(){}
    public static <T extends Comparable<T>> void sort(T[] arr) {
        for (int i=0; i<arr.length; i++) {
            T e = arr[i];
            int j=i;
            for (; j>0 && e.compareTo(arr[j-1])<0; j--) {
                arr[j] = arr[j-1];
            }
            arr[j] = e;
        }
    }
}

相比于选择排序的操作过程，插入排序的内层循环可以提前终止（如上代码的第7行，e.compareTo(arr[j-1])<0）；同时，插入排序使用赋值代替交换（交换需要3次赋值），也一定程度上提高了效率。

有点复杂的排序方法

两种O(nlogn)的排序算法都使用了分治的思想，将一个大问题分解成小的子问题来解决。小的子问题解决了，大问题也就解决了。
简单来讲，归并排序是将数组分为两部分，将两部分分别排序，再将这有序的两部分合并到一起，整个数组就有序了；快速排序是将一个元素e放在正确的位置上，将数组分为大于e和小于e两部分，层层递归。

归并排序

归并排序是非原地、稳定的排序算法。其平均时间复杂度为O(nlogn)，但在空间复杂度上，归并排序不同于其余几种排序，其空间复杂度为O(n)，需要额外的辅助空间。归并排序一般有两种思路，一种是自顶向下（迭代），一种是自底向上（循环）。

public class MergeSort {
  
    private MergeSort(){}
    
    public static <T extends Comparable<T>> void sortUp2Down(T[] arr) {
        sortUp2Down(0, arr.length-1, arr);
    }

    private static <T extends Comparable<T>> void sortUp2Down(int l, int r, T[] arr) {
        if (l>=r) {
            return;
        }
        int mid = l + (r-l)/2;
        sortUp2Down(l, mid, arr);
        sortUp2Down(mid+1, r, arr);
        merge(l, mid+1, r, arr);
    }

	/**
     * 将[l,mid-1]和[mid,r]合并
     * @param l 第1个参与合并的数组的起点索引
     * @param mid 第2个参与合并的数组的起点索引
     * @param r 第2个参与合并的数组的终点索引
     */
    private static <T extends Comparable<T>> void merge(int l, int mid, int r, T[] arr) {
    	// 声明额外空间，不是原地排序
        T[] temp = (T[]) new Comparable[r-l+1];      
        int i=l, j=mid;
        for (int index =0; index<temp.length; index++) {
            if (i>=mid) {
                temp[index] = arr[j++];
            } else if (j>=r+1) {
                temp[index] = arr[i++];
            } else if (arr[i].compareTo(arr[j])<=0) {  // 注意：有无“=”决定了算法是否稳定
                temp[index] = arr[i++];
            } else {
                temp[index] = arr[j++];
            }
        }
        // 将[l,r]在外部空间排序后拷贝回原数组
        for (int index=0; index<temp.length; index++) {    
            arr[index+l] = temp[index];
        }
    }

    public static <T extends  Comparable<T>> void sortDown2Up(T[] arr) {
        int n = arr.length;
        for (int sz=1; sz<n; sz*=2) {
            for (int i=0; i<n-sz; i+=2*sz) {
                int l=i;
                // 注意取值，不可以用(l+r)/2
                int mid = i+sz;          
                // 注意取值，小心越界                      
                int r = Math.min(i+2*sz-1, n-1);          
                // 优化，如果arr[mid-1]<=arr[mid]，说明已经有序     
                if (arr[mid-1].compareTo(arr[mid])>0) {        
                    merge(l, mid, r, arr);
                }
            }
        }
    }
}

我在写博客的时候，也参考了网上其他的写法。但其中有将sortDown2Up循环中的mid赋值为l+(r-l)/2，这一看好像没有问题，但其实这样是错误的。当arr.length != 2ⁿ时，数组无法在所有分组时都实现等分，这样会破坏已经排好序的小单元。
另外，归并排序还有很多优化方案。例如分组后元素较小时，使用插入排序。

快速排序

快速排序是原地、不稳定的排序算法，其平均时间复杂度为O(nlogn)，空间复杂度为O(1)。

public class QuickSort {
    private QuickSort(){}
    public static <T extends Comparable<T>> void sort(T[] arr) {
        partition(0, arr.length-1, arr);
    }
    private static <T extends Comparable<T>> void partition(int l, int r, T[] arr) {
        if (r<=l) {
            return;
        }
        // 降低分区不均衡的可能性，还可以采取三点取中法、十点取中法。
        int randIndex = (int) (Math.random()*(r-l+1) + l);  
        SortHelper.swap(l, randIndex, arr);
        // 最后一个小于arr[l]的元素的索引
        int k=l; 
        for (int i=l+1; i<=r; i++) {
            if (arr[i].compareTo(arr[l])<0) {
                SortHelper.swap(++k, i, arr);
            }
        }
        SortHelper.swap(l, k, arr);
        partition(l, k-1 ,arr);
        partition(k+1, r, arr);
    }
}

在分区不均衡时，有可能退化成时间复杂度为O(n²)的算法。

总结

统计上讲，肯定是时间复杂度为O(nlogn)的算法更快，但在某些情况下，比如数据量很小，或者有大量重复元素，又或者数据近乎有序，也许某些时间复杂度为O(n²)的算法有更好的表现。需要具体情况具体分析。

附录

public class SortHelper {
    private SortHelper(){}
    public static Object[] swap(Object[]arr, int i, int j){
        Object a = arr[j];
        arr[j] = arr[i];
        arr[i] = a;
        return arr;
    }
}