排序（用java实现）

排序的概念及引用

排序的概念

排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。
稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i] = r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。

内部排序：数据元素全部放在内存中的排序。
外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求在内外存之间移动数据的排序。

常见的排序算法

常见排序算法的实现

插入排序

基本思想：

直接插入排序是一种简单的插入排序算法，其基本思想是：
把待排序的记录按照其关键码值的大小逐个插入到有个已经排好序的有序序列中，直到所有的记录插入完为止，得到新的有序序列。实际中玩扑克牌，就用了插入排序的思想。

直接插入排序

当插入第 i (i>=1) 个元素时，前面的array[0],array[1],…,array[i-1] 已经排好序，此时用array[i]的排序码与array[i-1],array[i-2],…的排序码顺序进行比较，找到插入位置即将array[i]插入，原来位置上的元素顺序后移

    /**
     * 时间复杂度为：O(N^2)
     *      最坏情况下：逆序的   5 4 3 2 1
     *      最好情况下：本身就是有序的  1 2 3 4 5 O(n)
     *              如果数据越有序，直接插入排序越快
     * 空间复杂度：O(1)
     * 稳定性：稳定的排序
     *      本身如果是一个稳定的排序，那么可以实现为不稳定的
     *      但是 如果一个 排序 本身就是不稳定，能实现为稳定的排序吗？
     * @param array
     */
public static void insertSort(int[] array){
    for (int i = 1; i < array.length; i++) {
        int tmp = array[i];
        int j = i - 1;
        for (; j >= 0; j--) {
            if(array[j] > tmp){
                array[j+1] = array[j];
            }else {
                break;
            }
        }
        array[j+1] = tmp;
    }
}

public static void testSimple(){
    int[] array = {10,2,5,7,3};
    System.out.println("排序前："+ Arrays.toString(array));
    Sort.insertSort(array);
    System.out.println("排序后："+ Arrays.toString(array));
}

public static void main(String[] args) {
    testSimple();
}

时间复杂度为：1+2+3+4+…+N-1 = $\frac{(1+(N-1)\ast (N-1))}{2}$ = $\frac{N^2-N}{2}$ ，所以为O($N^2$)

直接插入排序的特性总结：

1. 元素集合越接近越有序，直接插入排序算法的时间效率越高
2. 时间复杂度：$O(N^2)$
3. 空间复杂度：$O(1)$，它是一种稳定的排序算法
4. 稳定性：稳定

希尔排序(缩小增量排序)

希尔排序又称缩小增量法。希尔排序法的基本思想：先选定一个整数，把待排序文件中所有记录分成多个组，所有距离为这个整数的记录在同一组内，并对每一组内的记录进行排序。然后再取，重复上述分组和排序的工作。当这个数=1时，所有记录在同一组内排好序。

/**
  * 不稳定的
  * 时间复杂度：n^1.3 - n^1.5
  * 空间复杂度：O(1)
  * @param array
  */
public static void shellSort(int[] array){
    int gap = array.length;
    while(gap > 1){
        gap /= 2;
        for (int i = gap; i < array.length; i++) {
            int tmp = array[i];
            int j = i - gap;
            for (; j >= 0; j = j - gap) {
                if(array[j] >= tmp){
                    array[j+gap] = array[j];
                }else {
                    break;
                }
            }
            array[j+gap] = tmp;
        }
    }
}

public static void testSimple(){
    int[] array = {10,2,5,7,3};
    System.out.println("排序前："+ Arrays.toString(array));
    Sort.shellSort(array);
    System.out.println("排序后："+ Arrays.toString(array));
}

public static void main(String[] args) {
    testSimple();
}
//结果为
//排序前：[10, 2, 5, 7, 3]
//排序后：[2, 3, 5, 7, 10]

希尔排序的特性总结：

1. 希尔排序是对直接插入排序的优化
2. 当gap > 1时都是预排序，目的是让数组更接近于有序，当gap == 1时，数组已经接近有序的了，这样就会很快，这样整体而言，可以达到优化的效果。
3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此在好些书中的希尔排序的时间复杂度都不固定：
   《数据结构(C语言版)》— 严蔚敏
   
   《数据结构-用面向对象方法与C++描述》— 殷人昆
   
   因为我们的gap是按照Knuth提出的方式取值的，而且Knuth进行了大量的试验统计，我们暂时就按照：O(n^1.25)到O(1.6*n^1.25)来算
4. 稳定性：不稳定

选择排序

基本思想：

每一次从待排序的数据元素中选出最小(或最大)的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

直接选择排序

• 在元素集合array[i] ~ array[i-1]中选择关键码最小(或最大)的元素
• 若它不是这组元素中最后一个元素(或第一个元素)，则将它与这组元素中的最后一个(第一个)元素交换
• 在剩余的array[i] ~ array[n-2](array[i+1] ~ array[n-1])集合中，重复上述步骤，直到集合剩一个元素。

public static void selectSort(int[] array){
    for (int i = 0; i < array.length; i++) {
        int minIndex = i;
        for (int j = i+1; j < array.length; j++) {
            if(array[j] < array[minIndex]){
                minIndex = j;
            }
        }
        swap(array,i,minIndex);
    }
}

private static void swap(int[] array, int j, int i) {
    int tmp = array[j];
    array[j] = array[i];
    array[i] = tmp;
}

public static void testSimple(){
    int[] array = {10,2,5,7,3};
    System.out.println("排序前："+ Arrays.toString(array));
    Sort.selectSort(array);
    System.out.println("排序后："+ Arrays.toString(array));
}
public static void main(String[] args) {
    testSimple();
}
//结果为
//排序前：[10, 2, 5, 7, 3]
//排序后：[2, 3, 5, 7, 10]

可以继续改进：

/**
 * 选择排序：
 * 时间复杂度：O(N^2)
 *      和数据是否有序无关
 * 空间复杂度：O(1)
 * 稳定性：不稳定的排序
 * @param array
 */
public static void selectSort(int[] array){
    int left = 0;
    int right = array.length - 1;
    while(left < right){
        int minIndex = left;
        int maxIndex = left;
        for (int i = left+1; i < right; i++) {
            if(array[minIndex] > array[i]){
                minIndex = i;
            }
            if(array[maxIndex] < array[i]){
                maxIndex = i;
            }
        }
        swap(array,left,minIndex);
        if(maxIndex == left){
            maxIndex = minIndex;
        }
        swap(array,right,maxIndex);
        left++;
        right--;
    }
}

private static void swap(int[] array, int j, int i) {
    int tmp = array[j];
    array[j] = array[i];
    array[i] = tmp;
}

public static void testSimple(){
    int[] array = {10,2,5,7,3};
    System.out.println("排序前："+ Arrays.toString(array));
    Sort.selectSort(array);
    System.out.println("排序后："+ Arrays.toString(array));
}
public static void main(String[] args) {
    testSimple();
}
//结果为
//排序前：[10, 2, 5, 7, 3]
//排序后：[2, 3, 5, 7, 10]

总结：

1. 直接选择排序好理解，但是效率不是很好，实际中很少使用
2. 时间复杂度：O(N²)
3. 空间复杂度：O(1)
4. 稳定性：不稳定

堆排序

堆排序(HeapSort)即利用堆的思想进行排序，是指利用堆积树(堆)这种数据结构所设计的一种排序算法，它是选择排序的一种，它是通过堆来进行选择数据。总共分为两个步骤：

1. 建堆
   • 升序：建大堆
   • 降序：建小堆
2. 利用堆删除思想来进行排序

建堆和堆删除中都用到了向下调整，因此掌握了向下调整，就可以完成堆排序。

/**
* 堆排序
* 时间复杂度：O(n * logN)
* 空间复杂度：O(1)
* 稳定性：不稳定
* @param array
*/
public static void heapSort(int[] array){
   int end = array.length - 1;
   createHeap(array);
   while(end >= 0){
       swap(array, end, 0);
       siftDown(array, 0, end);
       end--;
   }

}

public static void createHeap(int[] array) {
   for (int parent = (array.length - 2) / 2; parent >= 0; parent--) {
       siftDown(array, parent, array.length);
   }
}

/**
*
* @param array
* @param parent   每棵子树调整的根节点
* @param length    每棵子树调整的结束结点
*/
public static void siftDown(int[] array,int parent, int length){
   int child = parent * 2 + 1;
   while(child < length){
       if(child + 1 < length && array[child + 1] > array[child]){
           child++;
       }
       if(array[child] > array[parent]){
           swap(array,parent,child);
           parent = child;
           child = parent * 2 + 1;
       }else{
           break;
       }
   }
}

public static void testSimple(){
    int[] array = {10,2,5,7,3};
    System.out.println("排序前："+ Arrays.toString(array));
    Sort.heapSort(array);
    System.out.println("排序后："+ Arrays.toString(array));
}
public static void main(String[] args) {
    testSimple();
}
//结果为
//排序前：[10, 2, 5, 7, 3]
//排序后：[2, 3, 5, 7, 10]

时间复杂度为：排序之前需创建大根堆或小根堆，时间复杂度为O(N)，向下调整加每个结点的时间复杂度为：O(N * $lo{g}_{2}N$)，所以堆排序的时间复杂度为：O(N) + O(N * $lo{g}_{2}N$) = O(N * $lo{g}_{2}N$) ，详见堆排序这篇文章
总结：

1. 堆排序使用堆来选数，效率高了很多
2. 时间复杂度：O(N * $lo{g}_{2}N$)
3. 空间复杂度：O(1)
4. 稳定性：不稳定

交换排序

基本思想：所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。

冒泡排序

public static void  bubbleSort(int[] array){
    for (int i = 0; i < array.length - 1; i++) {
        for (int j = 0; j < array.length-1; j++) {
            if(array[j] > array[j+1]){
                swap(array,j,j+1);
            }
        }
    }
}

public static void testSimple(){
    int[] array = {10,2,5,7,3};
    System.out.println("排序前："+ Arrays.toString(array));
    Sort.bubbleSort(array);
    System.out.println("排序后："+ Arrays.toString(array));
}
public static void main(String[] args) {
    testSimple();
}
//结果为
//排序前：[10, 2, 5, 7, 3]
//排序后：[2, 3, 5, 7, 10]

可以加以改进：

/**
 * 冒泡排序：
 * 时间复杂度：【讨论 没有优化的情况下，也就是 没有下方的boolean元素和 -i操作】
 *              O(N^2)
 *              优化以后 可能会达到O(N)
 * 空间复杂度：O(1)
 * 稳定性：稳定的排序
 * @param array
 */
public static void  bubbleSort(int[] array){
    for (int i = 0; i < array.length - 1; i++) {
        boolean flag = false;
        for (int j = 0; j < array.length-1-i; j++) {
            if(array[j] > array[j+1]){
                swap(array,j,j+1);
                flag = true;
            }
        }
        if(!flag){
            break;
        }
    }
}

总结：

1. 冒泡排序是一种非常容易理解的排序
2. 时间复杂度：O(N²)
3. 空间复杂度：O(1)
4. 稳定性：稳定

快速排序

快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：任待取元素序列的某元素作为基准值，按照该序列将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后对左右子序列重复该过程，直到所有元素都排列在相应的位置上为止。

public static void quickSort(int[] array){
    quick(array,0,array.length - 1);
}

//假设按照升序对array数组中[left, right]区间中的元素进行排序
public static void quick(int[] array, int left, int right){
    if(left >= right){
        return;
    }

    //按照基准值对array数组的[left, right]区间中的元素进行划分
    int div = partion(array, left, right);

    //划分成功后以div为边界形成了左右两部分[left, div-1]和[div+1, right]
    //递归排[left, div-1]
    quick(array, left, div-1);

    //递归排[div+1, right]
    quick(array,div+1, right);
}

上述为快速排序递归实现的主框架，发现与二叉树前序遍历规则非常像，所以写递归框架可想想二叉树前序遍历规则即可快速写出来，后续只需分析如何按照基准值来对区间中数据进行划分的方式即可。
将区间按照基准值划分为左右两部分的常见方式有：

1. Hoare版
   
   

private static void swap(int[] array, int j, int i) {
    int tmp = array[j];
    array[j] = array[i];
    array[i] = tmp;
}
/**
     * 时间复杂度：
     *          最坏情况：当数据指定的是1 2 3 4 ......有序的情况下，确实是O(n^2)
     *                                9 8 7 6 ......
     *          最好情况：O(n * logN)
     * 空间复杂度：
     *      最坏情况下：O(N)
     *      最好情况下：O(logN)
     * 稳定性：
     *      不稳定
     * @param array
     */
public static void quickSort(int[] array){
    quick(array,0,array.length - 1);
}

//假设按照升序对array数组中[left, right]区间中的元素进行排序
public static void quick(int[] array, int left, int right){
    if(left >= right){
        return;
    }

    //按照基准值对array数组的[left, right]区间中的元素进行划分
    int div = partition(array, left, right);

    //划分成功后以div为边界形成了左右两部分[left, div-1]和[div+1, right]
    //递归排[left, div-1]
    quick(array, left, div-1);

    //递归排[div+1, right]
    quick(array,div+1, right);
}

public static int partition(int[] array, int left, int right){
    int tmp = array[left];
    int tmpLeft = left;
    while(left < right){
        while(left < right && array[right] >= tmp){
            right--;
        }
        while(left < right && array[left] <= tmp){
            left++;
        }
        swap(array,left,right);
    }
    swap(array,left,tmpLeft);
    return left;
}

public static void testSimple(){
    int[] array = {10,2,5,7,3};
    System.out.println("排序前："+ Arrays.toString(array));
    Sort.quickSort(array);
    System.out.println("排序后："+ Arrays.toString(array));
}
public static void main(String[] args) {
    testSimple();
}
//结果为
//排序前：[10, 2, 5, 7, 3]
//排序后：[2, 3, 5, 7, 10]

2. 挖坑法

public static void quickSort(int[] array){
    quick(array,0,array.length - 1);
}

//假设按照升序对array数组中[left, right]区间中的元素进行排序
public static void quick(int[] array, int left, int right){
    if(left >= right){
        return;
    }

    //按照基准值对array数组的[left, right]区间中的元素进行划分
    int div = partition(array, left, right);

    //划分成功后以div为边界形成了左右两部分[left, div-1]和[div+1, right]
    //递归排[left, div-1]
    quick(array, left, div-1);

    //递归排[div+1, right]
    quick(array,div+1, right);
}

public static int partition(int[] array, int left, int right){
    int tmp = array[left];
    while(left < right){
        while(left < right && array[right] > tmp){
            right--;
        }
        array[left] = array[right];
        while(left < right && array[left] < tmp){
            left++;
        }
        array[right] = array[left];
    }
    array[left] = tmp;
    return left;
}

public static void testSimple(){
    int[] array = {10,2,5,7,3};
    System.out.println("排序前："+ Arrays.toString(array));
    Sort.quickSort(array);
    System.out.println("排序后："+ Arrays.toString(array));
}
public static void main(String[] args) {
    testSimple();
}
//结果为
//排序前：[10, 2, 5, 7, 3]
//排序后：[2, 3, 5, 7, 10]

3. 前后指针
   

public static void quickSort(int[] array){
    quick(array,0,array.length - 1);
}

//假设按照升序对array数组中[left, right]区间中的元素进行排序
public static void quick(int[] array, int left, int right){
    if(left >= right){
        return;
    }

    //按照基准值对array数组的[left, right]区间中的元素进行划分
    int div = partition(array, left, right);

    //划分成功后以div为边界形成了左右两部分[left, div-1]和[div+1, right]
    //递归排[left, div-1]
    quick(array, left, div-1);

    //递归排[div+1, right]
    quick(array,div+1, right);
}

public static int partition(int[] array, int left, int right){
    int prev = left;
    int cur = left+1;
    int key = left;
    while(cur <= right){
        if(array[cur] < array[key] && array[++prev] != array[cur]){
            swap(array,prev,cur);
        }
        cur++;
    }
    swap(array,prev,key);
    return left;
}

public static void testSimple(){
    int[] array = {10,2,5,7,3};
    System.out.println("排序前："+ Arrays.toString(array));
    Sort.quickSort(array);
    System.out.println("排序后："+ Arrays.toString(array));
}
public static void main(String[] args) {
    testSimple();
}
//结果为
//排序前：[10, 2, 5, 7, 3]
//排序后：[2, 3, 5, 7, 10]

快速排序的优化

由于快排使用递归，若待排序列是有序的或无序的，所开辟的栈是需要很多的，空间复杂度达到O(N)，所以为了减少栈的开辟，提高空间的利用率和时间成本，对此进行了优化

1. 三数取中选key
   
   

public static void quickSort(int[] array){
    quick(array,0,array.length - 1);
}

public static void quick(int[] array, int left, int right){
    if(left >= right){
        return;
    }

    int midIndex = getMiddleNum(array,left,right);
    swap(array,midIndex,left);
    int div = partition(array, left, right);

    quick(array, left, div-1);

    quick(array,div+1, right);
}
public static int partition(int[] array, int left, int right){
    int tmp = array[left];
    while(left < right){
        while(left < right && array[right] > tmp){
            right--;
        }
        array[left] = array[right];
        while(left < right && array[left] < tmp){
            left++;
        }
        array[right] = array[left];
    }
    array[left] = tmp;
    return left;
}

public static void testSimple(){
    int[] array = {10,2,5,7,3};
    System.out.println("排序前："+ Arrays.toString(array));
    Sort.quickSort(array);
    System.out.println("排序后："+ Arrays.toString(array));
}
public static void main(String[] args) {
    testSimple();
}
//结果为
//排序前：[10, 2, 5, 7, 3]
//排序后：[2, 3, 5, 7, 10]

2. 递归到小的子区间时，可以考虑使用插入排序
   对于排序，越排是越有序的，而且对于二叉树来讲，越到后面结点越集中，所需开辟的空间越多，但是更有序，对于有序的序列，直接插入排序是最快的。

public static void quickSort(int[] array){
   quick(array,0,array.length - 1);
}

public static void quick(int[] array, int left, int right){
   if(left >= right){
       return;
   }

   if(right - left + 1 <= 7){
       insertSortRange(array,left,right);
       return;
   }

   int midIndex = getMiddleNum(array,left,right);
   swap(array,midIndex,left);
   int div = partition(array, left, right);

   quick(array, left, div-1);

   quick(array,div+1, right);
}

private static void insertSortRange(int[] array, int left, int right) {
   for (int i = left+1; i < right; i++) {
       int tmp = array[i];
       int j = i-1;
       for (; j >= left; j--) {
           if(array[j] > array[j+1]){
               array[j+1] = array[j];
           }else{
               array[j+1] = tmp;
               break;
           }
       }
       array[j+1] = tmp;
   }
}

public static int partition(int[] array, int left, int right){
   int tmp = array[left];
   while(left < right){
       while(left < right && array[right] > tmp){
           right--;
       }
       array[left] = array[right];
       while(left < right && array[left] < tmp){
           left++;
       }
       array[right] = array[left];
   }
   array[left] = tmp;
   return left;
}

public static void testSimple(){
    int[] array = {10,2,5,7,3};
    System.out.println("排序前："+ Arrays.toString(array));
    Sort.quickSort(array);
    System.out.println("排序后："+ Arrays.toString(array));
}
public static void main(String[] args) {
    testSimple();
}
//结果为
//排序前：[10, 2, 5, 7, 3]
//排序后：[2, 3, 5, 7, 10]

快速排序非递归

public static void quickSort(int[] array){
    quickNor(array,0,array.length - 1);

}
public static void quickNor(int[] array, int left, int right){
    Stack<Integer> stack = new Stack<>();
    int div = partition(array,left,right);
    if(div > left + 1){
        stack.push(left);
        stack.push(div-1);
    }
    if(div < right-1){
        stack.push(div+1);
        stack.push(right);
    }
    while(!stack.isEmpty()){
        right = stack.pop();
        left = stack.pop();
        div = partition(array,left,right);
        if(div > left + 1){
            stack.push(left);
            stack.push(div-1);
        }
        if(div < right-1){
            stack.push(div+1);
            stack.push(right);
        }
    }
}
public static int partition(int[] array, int left, int right){
    int tmp = array[left];
    while(left < right){
        while(left < right && array[right] > tmp){
            right--;
        }
        array[left] = array[right];
        while(left < right && array[left] < tmp){
            left++;
        }
        array[right] = array[left];
    }
    array[left] = tmp;
    return left;
}

public static void testSimple(){
    int[] array = {10,2,5,7,3};
    System.out.println("排序前："+ Arrays.toString(array));
    Sort.quickSort(array);
    System.out.println("排序后："+ Arrays.toString(array));
}
public static void main(String[] args) {
    testSimple();
}
//结果为
//排序前：[10, 2, 5, 7, 3]
//排序后：[2, 3, 5, 7, 10]

总结：

1. 快速排序整体的综合性能和使用场景都是比较好的
2. 时间复杂度：O(N*$lo{g}_{2}N$)
   
3. 空间复杂度：O($lo{g}_{2}N$)
4. 稳定性：不稳定

归并排序

基本思想

归并排序(MEGRE-SORT)是建立在归并操作上的一种有效的排序算法，该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列：即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路合并。归并排序核心步骤：分解和合并

归并排序

public static void mergeSort(int[] array){
    merge(array,0,array.length-1);
}

private static void merge(int[] array, int left, int right) {
    if(left >= right){
        return;
    }
    int mid = (left + right) / 2;
    merge(array,left,mid);
    merge(array,mid+1,right);
    
}

/**
 * 归并排序：
 * 时间复杂度：O(N * logN)
 * 空间复杂度：O(N)
 * 稳定性：稳定
 * @param array
 */
public static void mergeSort(int[] array){
    mergeSortTmp(array,0,array.length-1);
}

private static void mergeSortTmp(int[] array, int left, int right) {
    if(left >= right){
        return;
    }
    int mid = (left + right) / 2;
    mergeSortTmp(array,left,mid);
    mergeSortTmp(array,mid+1,right);

    merge(array,left,right,mid);

}

private static void merge(int[] array, int left, int right, int mid) {
    int s1 = left;
    //int e1 = mid;
    int s2 = mid+1;
    //int e2 = right;
    int k = 0;
    int len = right - left + 1;
    int tmp[] = new int[len];
    while(s1 <= mid && s2 <= right){
        if(array[s1] > array[s2]){
            tmp[k++] = array[s2++];
        }else{
            tmp[k++] = array[s1++];
        }
    }
    while(s1 <= mid){
        tmp[k++] = array[s1++];
    }
    while(s2 <= right){
        tmp[k++] = array[s2++];
    }
    for (int i = 0; i < tmp.length; i++) {
        array[i+left] = tmp[i];
    }
}

public static void testSimple(){
    int[] array = {10,2,5,7,3};
    System.out.println("排序前："+ Arrays.toString(array));
    Sort.mergeSort(array);
    System.out.println("排序后："+ Arrays.toString(array));
}
public static void main(String[] args) {
    testSimple();
}
//结果为
//排序前：[10, 2, 5, 7, 3]
//排序后：[2, 3, 5, 7, 10]

归并排序的非递归

public static void mergeSortNor(int[] array){
    int gap = 1;
    while(gap < array.length){
        gap = gap * 2;
        for (int i = 0; i < array.length; i = i+gap*2) {
            int left = i;
            int right = left + gap - 1;
            if(right >= array.length){
                right = array.length-1;
            }
            int mid = (left + right) / 2;
            if(mid >= array.length){
                mid = array.length-1;
            }

            merge(array,left,right,mid);
        }
    }
}

private static void merge(int[] array, int left, int right, int mid) {
    int s1 = left;
    //int e1 = mid;
    int s2 = mid+1;
    //int e2 = right;
    int k = 0;
    int len = right - left + 1;
    int tmp[] = new int[len];
    while(s1 <= mid && s2 <= right){
        if(array[s1] > array[s2]){
            tmp[k++] = array[s2++];
        }else{
            tmp[k++] = array[s1++];
        }
    }
    while(s1 <= mid){
        tmp[k++] = array[s1++];
    }
    while(s2 <= right){
        tmp[k++] = array[s2++];
    }
    for (int i = 0; i < tmp.length; i++) {
        array[i+left] = tmp[i];
    }
}

public static void testSimple(){
    int[] array = {10,2,5,7,3};
    System.out.println("排序前："+ Arrays.toString(array));
    Sort.mergeSortNor(array);
    System.out.println("排序后："+ Arrays.toString(array));
}
public static void main(String[] args) {
    testSimple();
}
//结果为
//排序前：[10, 2, 5, 7, 3]
//排序后：[2, 3, 5, 7, 10]

总结：

1. 归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多是解决在磁盘中的外排序问题。
2. 时间复杂度：O(N*$lo{g}_{2}N$)
3. 空间复杂度：O(N)
4. 稳定性：稳定

海量数据的排序问题

外部排序：排序过程需要在磁盘等外部存储进行的排序
前提：内存只有1G，需要排序的数据有100G
因为内存中因为无法把所有数据全部放下，所以需要外部排序，而归并排序是最常用的外部排序

1. 先把文件切分成200份，每个512M
2. 分别对512M排序，因为内存已经可以放得下，所以任意排序方式都可以
3. 进行2路归并，同时对200份有序文件做归并过程，最终结果就有序了

排序算法复杂度及稳定性分析

其他非基于比较排序

1. 计数排序
   思想：计数排序又称为鸽巢原理，是对哈希直接定址法的变形应用。操作步骤：
   1. 统计相同元素出现次数
   2. 根据统计的结果将序列回收到原来的序列中
   
   计数排序的特性总结：
   1. 计数排序在数据范围集中时，效率很高，但是适用范围及场景有限
   2. 时间复杂度：O(Max(N,范围))
   3. 空间复杂度：O(范围)
   4. 稳定
2. 基数排序
3. 桶排序

选择题

1.快速排序算法是基于()的一个排序算法。
A：分治法 B：贪心法 C：递归法 D：动态规划法
答案：A
没有递归法这种说法
2.对记录（54,38,96,23,15,72,60,45,83）进行从小到大的直接插入排序时，当把第8个记录45插入到有序表时，为找到插入位置需比较()次？（采用从后往前比较）
A: 3 B: 4 C: 5 D: 6

答案：C
3.设一组初始记录关键字序列为(65,56,72,99,86,25,34,66)，则以第一个关键字65为基准而得到的一趟快速排序结果是（）
A: 34，56，25，65，86，99，72，66 B: 25，34，56，65，99，86，72，66
C: 34，56，25，65，66，99，86，72 D: 34，56，25，65，99，86，72，66

答案： A
4.以下排序方式中占用O(n)辅助存储空间的是()
A: 简单排序 B: 快速排序 C: 堆排序 D: 归并排序
答案：D
5.4.下列排序算法中稳定且时间复杂度为O(n^2)的是()
A: 快速排序 B: 冒泡排序 C: 直接选择排序 D: 归并排序
答案：B
6.关于排序，下面说法不正确的是()
A: 快排时间复杂度为O(N*logN)，空间复杂度为O(logN)
B: 归并排序是一种稳定的排序,堆排序和快排均不稳定
C: 序列基本有序时，快排退化成 “冒泡排序”，直接插入排序最快
D: 归并排序空间复杂度为O(N), 堆排序空间复杂度的为O(logN)
答案：D

这篇文章先了解到这，希望对大家有帮助，多谢阅读！！！