1、衡量排序算法的标准

　　其实几乎所有算法都可以从几个方便进行衡量：执行效率、内存开销、稳定性。

　　排序算法也一样，主要从：

　　　　• 时间复杂度，包括：最好情况、最坏情况、平均时间复杂度、还有比较和交换的次数

　　　　• 空间复杂度，如：原地排序

　　　　• 排序算法的稳定性，即相同数值的元素，排序后的前后顺序不变则称为稳定排序

　　来汇总一下常用排序算法：

2、冒泡、插入和选择

2.1、冒泡排序

　　举个简单的例子：对数组[4,5,6,3,2,1]进行排序。看下冒泡过程分解：

　　冒泡排序包含两个关键操作：比较和交换，根据上面的分析，我们写出具体的代码：　　　　　

// 冒泡排序，a表示数组，n表示数组大小
public void bubbleSort(int[] a, int n) {
  if (n <= 1) return;
 
 for (int i = 0; i < n; ++i) {
    // 提前退出冒泡循环的标志位
    boolean flag = false;
    for (int j = 0; j < n - i - 1; ++j) {
      if (a[j] > a[j+1]) { // 交换
        int tmp = a[j];
        a[j] = a[j+1];
        a[j+1] = tmp;
        flag = true;  // 表示有数据交换      
      }
    }
    if (!flag) break;  // 没有数据交换，提前退出
  }
}

　　冒泡排序比较简单，注意这里我们设置了一个退出标志位，当数组已经当前位置后续元素已经有序的情况下，减少不必要的循环逻辑。

　　冒泡排序的最好情况下时间复杂度，即数组有序时（1，2，3，4，5，6），是O(n)；最坏情况时间复杂度，即数组逆序（6，5，4，3，2，1），是O(n²)；平均时间复杂度是 O(n²)。

　　冒泡排序是原地排序，空间复杂度 O(1)。

　　冒泡排序是稳定是排序，因为 a[j] == a[j+1] 时没有进行交换，所以前后顺序不会变。

2.2、插入排序

　　插入排序思想：将数组中的数据分为两个区间，已排序区间和未排序区间。初始已排序区间只有一个元素，就是数组的第一个元素。然后取未排序区间中的元素，在已排序区间中找到合适的插入位置将其插入，并保证已排序区间数据一直有序。重复这个过程，直到未排序区间中元素为空，算法结束。

　　对数组[4,5,6,3,2,1]进行排序，看下插入过程分解：

　　根据以上分析，我们写出具体代码：

// 插入排序，a表示数组，n表示数组大小
public void insertionSort(int[] a, int n) {
  if (n <= 1) return;

  for (int i = 1; i < n; ++i) {
    int value = a[i];// 查找插入的位置
    for (int j=i-1; j >= 0; --j) {
      if (a[j] > value) {
        a[j+1] = a[j];  // 数据移动
      } else {
        break;
      }
    }
    a[j+1] = value; // 插入数据，注意这里是a[j+1]，因为循环结束找到要插入位置后，后面的--j还会执行。
  }
}

　　插入排序的最好情况下时间复杂度，即数组有序时（1，2，3，4，5，6），是O(n)；最坏情况时间复杂度，即数组逆序（6，5，4，3，2，1），是O(n²)；平均时间复杂度是 O(n²)。

　　插入排序是原地排序，空间复杂度 O(1)。

　　插入排序是稳定是排序，因为 a[j] == value 时没有将 a[j] 移动，所以前后顺序不会变。

2.3、选择排序

　　选择排序算法的实现思路有点类似插入排序，也分已排序区间和未排序区间。但是选择排序每次会从未排序区间中找到最小的元素，将其放到已排序区间的末尾。

　　根据以上分析，我们写出代码：

// 选择排序，a表示数组，n表示数组大小
public void selectSort(int[] a, int n) {
  if (n <= 1) return;

  for (int i = 0; i < n; ++i) {
    int min_idx = i;
    // 找到最小元素的位置
    for (int j=i+1; j < n; ++j) {
      if (a[j] < a[min_idx]) {
        min_idx = j;
      } 
    }
    //移动未排序区最小元素到排序区
    if(min_idx != i){
       int tmp = a[i];
       a[i] = a[min_idx];
       a[min_idx] = tmp;
    }
  }
}

　　选择排序的最好情况下时间复杂度，即数组有序时（1，2，3，4，5，6），是O(n)；最坏情况时间复杂度，即数组逆序（6，5，4，3，2，1），是O(n²)；平均时间复杂度是 O(n²)。

　　选择排序是原地排序，空间复杂度 O(1)。

　　选择排序是不稳定是排序，因为每次都要找到未排序区最小元素和前面的元素交换位置，这样破坏了稳定性。例如：[5,8,5,2,4]，当第一个5和2交换位置时稳定性就被破坏了。

3、快速和归并

　　快速排序和归并排序都用到了分治思想，适合大规模数据排序，比上面三种更常用。

3.1、归并排序

　　 归并排序的核心思想是：把数组从中间分成前后两部分，然后对前后两部分分别排序，再将排好序的两部分合并在一起，这样整个数组就都有序了。

　　分治思想都会用到递归，我们来看下递推公式：

　　　　merge_sort(p..r) = merge_sort(p...m) + merge_sort(m+1...r)，终止条件：当 p >= r 时不再继续分解。

　　到这里，分解的过程就结束了，但是分解后还有一个合并的过程，就是将已经有序的 A[p...m] 和 A[m+1...r] 合并成一个有序数组，然后放入 A[p...r]。

　　合并的逻辑：申请一个临时数组 tmp，大小与 A[p...r] 相同。用两个游标 i 和 j，分别指向 A[p...m]和 A[m+1...r]的第一个元素。比较这两个元素 A[i] 和 A[j]，如果 A[i]<=A[j]，就把 A[i] 放入到临时数组 tmp，并且 i 后移一位，否则将 A[j]放入到数组 tmp，j 后移一位。继续上述比较过程，直到其中一个子数组中的所有数据都放入临时数组中，再把另一个数组中的数据依次加入到临时数组的末尾，这个时候，临时数组中存储的就是两个子数组合并之后的结果了。最后再把临时数组 tmp 中的数据拷贝到原数组 A[p...r]中。

　　根据以上分析，我们写出整个分解与合并的代码：

public class MergeSort {

    public static void main(String[] args) {
        int[] arr = {4,5,6,3,2,1};
        int len = arr.length;
        sort(arr,0,len-1);
        for (int item : arr){
            System.out.print(item);
        }
    }

    /**
     * 分解
     */
    private static void sort(int[] arr,int left,int right){
        //终止条件
        if (left >= right)return;

        int mid = (left+right) / 2;

        sort(arr,left,mid);
        sort(arr,mid+1,right);
        //如果两个数组已经有序，就不用再合并了
        if (arr[mid] <= arr[mid+1]){
            return;
        }
        //合并两段区间
        merge(arr,left,mid,right);
    }

    /**
     * 合并
     */
    private static void merge(int[] arr,int left,int mid,int right){
        //创建临时数组
        int[] tmp = new int[right-left+1];

        int i=left,j=mid+1;
        for (int k=0;k<tmp.length;k++){
            //如果左侧
            if (i == mid+1){
                tmp[k] = arr[j++];
            }else if (j == right+1){
                tmp[k] = arr[i++];
            }
            //这一步如果去掉等号，就破坏调了稳定性
            else if (arr[i] <= arr[j]){
                tmp[k] = arr[i++];
            }else {
                tmp[k] = arr[j++];
            }
        }
        //采用Java自带的数组拷贝，也可以写个循环
        System.arraycopy(tmp, 0,arr, left, tmp.length);
    }
}

public class MergeSort {

    public static void main(String[] args) {
        int[] arr = {4,5,6,3,2,1};
        int len = arr.length;
        sort(arr,0,len-1);
        for (int item : arr){
            System.out.print(item);
        }
    }

    /**
     * 分解
     */
    private static void sort(int[] arr,int left,int right){
        //终止条件
        if (left >= right)return;

        int mid = (left+right) / 2;

        sort(arr,left,mid);
        sort(arr,mid+1,right);
        //如果两个数组已经有序，就不用再合并了
        if (arr[mid] <= arr[mid+1]){
            return;
        }
        //合并两段区间
        merge(arr,left,mid,right);
    }

    /**
     * 合并
     */
    private static void merge(int[] arr,int left,int mid,int right){
        //创建临时数组
        int[] tmp = new int[right-left+1];

        int i=left,j=mid+1;
        for (int k=0;k<tmp.length;k++){
            //如果左侧
            if (i == mid+1){
                tmp[k] = arr[j++];
            }else if (j == right+1){
                tmp[k] = arr[i++];
            }
            //这一步如果去掉等号，就破坏调了稳定性
            else if (arr[i] <= arr[j]){
                tmp[k] = arr[i++];
            }else {
                tmp[k] = arr[j++];
            }
        }
        //采用Java自带的数组拷贝，也可以写个循环
        System.arraycopy(tmp, 0,arr, left, tmp.length);
    }
}