大家好，我是晓星航。今天为大家带来的是 Java排序相关内容的讲解！😀

🐾1. 概念🐾

1.1 排序

排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。

平时的上下文中，如果提到排序，通常指的是排升序（非降序）。

通常意义上的排序，都是指的原地排序(in place sort)。

1.2 稳定性（重要）

两个相等的数据，如果经过排序后，排序算法能保证其相对位置不发生变化，则我们称该算法是具备稳定性的排序算法。

1.3 应用

1.各大商城的价格从低到高等
2.中国大学排名

💐2. 七大基于比较的排序比-总览💐

简历上这么写：熟悉常见的排序算法：如：快速排序，堆排序，归并排序

🌸3. 插入排序🌸

3.1 直接插入排序-原理

整个区间被分为

有序区间
无序区间

每次选择无序区间的第一个元素，在有序区间内选择合适的位置插入

3.2 实现

取出array[i]给tmp，如果前面＞后面则后面赋值为前面的值，直到前面<后面，将tmp直接给前面完成插入排序。

/**
 * 时间复杂度：O(N^2)
 *      最好的情况时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 {
                //array[j + 1] = tmp;  只要j回退的时候，遇到了 比tmp小的元素就结束这次的比较
                break;
            }
        }
        //j回退到了 小于0 的地方
        //第一次的j = -1; 之后的j值与上面if什么时候break有关
        array[j + 1] = tmp;
    }
}
public static void main(String[] args) {
    int[] array = {12,5,8,13,29,3,4};
    insertSort(array);
    System.out.println(Arrays.toString(array));
}

3.3 性能分析

稳定性：稳定

插入排序，初始数据越接近有序，时间效率越高。

    /**
     * 有序的数据
     * @param capacity
     */
    public static void test1(int capacity) {
        int[] array = new int[capacity];
        for (int i = 0; i < array.length; i++) {
            array[i] = i;
        }
        long start = System.currentTimeMillis();
        insertSort(array);
//        shellSort(array);
//        selectSort(array);
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
    /**
     * 无序的数据
     * @param capacity
     */
    public static void test2(int capacity) {
        int[] array = new int[capacity];
        Random random = new Random();
        for (int i = 0; i < array.length; i++) {
            array[i] = random.nextInt(capacity);
        }
        long start = System.currentTimeMillis();
        insertSort(array);
//        shellSort(array);
//        selectSort(array);
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
    public static void main(String[] args) {
        test1(10_0000);
        test2(10_0000);
    }

由上图可知插入排序排10万个有序数据和无序数据所需的时间分别为0和1779。

3.4 折半插入排序（了解）

在有序区间选择数据应该插入的位置时，因为区间的有序性，可以利用折半查找的思想。

public static void bsInsertSort(int[] array) {
    for (int i = 1; i < array.length; i++) {
        int v = array[i];
        int left = 0;
        int right = i;
        // [left, right)
        // 需要考虑稳定性
        while (left < right) {
            int m = (left + right) / 2;
            if (v >= array[m]) {
                left = m + 1;
            } else {
                right = m;
            }
        }
        // 搬移
        for (int j = i; j > left; j--) {
            array[j] = array[j - 1];
        }
        array[left] = v;
    }
}

🌷4. 希尔排序🌷

4.1 原理

思考：假设现在有10000个数据如果对这组数据进行排序，使用插入排序 10000个数据 * 10000 = 1 0000 0000 ->1个亿

若采取100组 100 * 100 = 10000 分组的思想，我们会发现时间复杂度会有一个很大的改变

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

1.希尔排序是对直接插入排序的优化。【即先分组–>(变有序)再排序】

2.当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果。

我们实现后可以进行性能测试的对比。

上述分组为正常分组

如果按照跳跃式分组我们则能将更多的更小的数放到前面，上述图为按五组来分。

上述图为按照3组来跳跃式分组并进行排序。

4.2 实现

/**
 *
 * @param array 待排序序列
 * @param gap 数组
 */
public static void shell(int[] array, int gap) {
    for (int i = gap; i < array.length; i++) {
        int tmp = array[i];
        int j = i - gap;
        for (; j >= 0; j-=gap) {
            if (array[j] > tmp) {
                array[j + gap] = array[j];
            } else {
                break;
            }
        }
        array[j + gap] = tmp;
    }
}
/**
 * 时间复杂度[和增量有关系]：O(n^1.3 - n^1.5)
 * 空间复杂度：O(1)
 * 稳定性：不稳定的
 *   看在比较的过程中  是否发生了跳跃式的交换  如果发生了跳跃式的交换 那么就是不稳定的排序
 * 基本上没有考过
 * @param array
 */
public static void shellSort(int[] array) {
    int gap = array.length;
    while (gap > 1) {
        shell(array,gap);
        gap /= 2;
    }
    shell(array,1);//保证最后是一组
}
public static void main(String[] args) {
    int[] array = {12,5,8,13,29,3,4,23,14,25,42,2,7};
    shellSort(array);
    System.out.println(Arrays.toString(array));
}

4.3 性能分析

时间复杂度：O(n^1.3 - n^1.5)

稳定性：不稳定

    /**
     * 有序的数据
     * @param capacity
     */
    public static void test1(int capacity) {
        int[] array = new int[capacity];
        for (int i = 0; i < array.length; i++) {
            array[i] = i;
        }
        long start = System.currentTimeMillis();
//        insertSort(array);
        shellSort(array);
//        selectSort(array);
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
    /**
     * 无序的数据
     * @param capacity
     */
    public static void test2(int capacity) {
        int[] array = new int[capacity];
        Random random = new Random();
        for (int i = 0; i < array.length; i++) {
            array[i] = random.nextInt(capacity);
        }
        long start = System.currentTimeMillis();
//        insertSort(array);
        shellSort(array);
//        selectSort(array);
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
    public static void main(String[] args) {
        test1(10_0000);
        test2(10_0000);
    }

由上图可知希尔排序排10万个有序数据和无序数据所需的时间分别为0和16。

因此希尔排序的时间效率大大优于插入排序！！！

🍀5. 选择排序🍀

5.1 直接选择排序-原理

每一次从无序区间选出最大（或最小）的一个元素，存放在无序区间的最后（或最前），直到全部待排序的数据元素排完。

每次都拿一个元素与后面元素依次比较，如果后面元素更小(更大)则交换，否则不变。

5.2 实现

public static void swap(int[] array,int i,int j) {
    int tmp = array[i];
    array[i] = array[j];
    array[j] = tmp;
}
/**
 * 选择排序
 * 时间复杂度：O(N^2)
 * 空间复杂度：O(1)
 * 稳定性：不稳定的排序
 * @param array 待排序的序列
 */
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);
    }
}
public static void main(String[] args) {
    int[] array = {12,5,8,13,29,3,4,23,14,25,42,2,7};
    selectSort(array);
    System.out.println(Arrays.toString(array));
}

5.3 性能分析

稳定性：不稳定

int[] a = { 9, 2, 5a, 7, 4, 3, 6, 5b };
// 交换中该情况无法识别，保证 5a 还在 5b 前边

    /**
     * 有序的数据
     * @param capacity
     */
    public static void test1(int capacity) {
        int[] array = new int[capacity];
        for (int i = 0; i < array.length; i++) {
            array[i] = i;
        }
        long start = System.currentTimeMillis();
//        insertSort(array);
//        shellSort(array);
        selectSort(array);
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
    /**
     * 无序的数据
     * @param capacity
     */
    public static void test2(int capacity) {
        int[] array = new int[capacity];
        Random random = new Random();
        for (int i = 0; i < array.length; i++) {
            array[i] = random.nextInt(capacity);
        }
        long start = System.currentTimeMillis();
//        insertSort(array);
//        shellSort(array);
        selectSort(array);
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
    public static void main(String[] args) {
        test1(10_0000);
        test2(10_0000);
    }

由上图可知选择排序排10万个有序数据和无序数据所需的时间分别为705和2914，数据的有序和无序对时间的消耗并不是那么明显。

5.4 双向选择排序（了解）

每一次从无序区间选出最小 + 最大的元素，存放在无序区间的最前和最后，直到全部待排序的数据元素排完。

public static void selectSortOP
        (int[] array) {
    int low = 0;
    int high = array.length - 1;
    // [low, high] 表示整个无序区间
    // 无序区间内只有一个数也可以停止排序了
    while (low <= high) {
        int min = low;
        int max = low;
        for (int i = low + 1; i <= max; i++) {
            if (array[i] < array[min]) {
                min = i;
            }
            if (array[i] > array[max]) {
                max = i;
            }
        }
        swap(array, min, low);
        // 见下面例子讲解
        if (max == low) {
            max = min;
        }
        swap(array, max, high);
    }
}
private void swap(int[] array, int i, int j) {
    int t = array[i];
    array[i] = array[j];
    array[j] = t;
}

array = { 9, 5, 2, 7, 3, 6, 8 }; // 交换之前
// low = 0; high = 6
// max = 0; min = 2
array = { 2, 5, 9, 7, 3, 6, 8 }; // 将最小的交换到无序区间的最开始后
// max = 0，但实际上最大的数已经不在 0 位置，而是被交换到 min 即 2 位置了
// 所以需要让 max = min 即 max = 2
array = { 2, 5, 8, 7, 3, 6, 9 }; // 将最大的交换到无序区间的最结尾后

🌻6. 堆排序🌻

6.1 原理

基本原理也是选择排序，只是不在使用遍历的方式查找无序区间的最大的数，而是通过堆来选择无序区间的最大的数。

注意：排升序要建大堆；排降序要建小堆。

堆排序

6.2 实现

/**
 *时间复杂度：O(N * log N)
 * 空间复杂度：O(1)
 * 稳定性：不稳定
 * @param array
 */
public static void heapSort(int[] array) {
    //1/建堆O(N)
    createHeap(array);
    int end = array.length - 1;
    //2、交换然后调整 O(N * log N)
    while (end > 0) {
        swap(array,0,end);
        shiftDown(array,0,end);
        end--;
    }
}
public static void createHeap(int[] array) {
    for (int parent = (array.length-1-1)/2; parent >= 0; parent--) {
        shiftDown(array,parent,array.length);
    }
}
public static void shiftDown(int[] array,int parent,int len) {
    int child = parent * 2 + 1;//左孩子下标
    while (child < len) {
        if (child + 1 < len && array[child] < array[child + 1]) {
            child++;
        }
        //child下标 就是左右孩子最大值的下标
        if (array[parent] < array[child]) {
            swap(array,parent,child);
            parent = child;
            child = parent * 2 + 1;
        } else {
            break;
        }
    }
}
public static void main(String[] args) {
    int[] array = {12,5,8,13,29,3,27,19,12,0,14,25,42,2,7};
    heapSort(array);
    System.out.println(Arrays.toString(array));
}

6.3 性能分析

稳定性：不稳定

    /**
     * 有序的数据
     * @param capacity
     */
    public static void test1(int capacity) {
        int[] array = new int[capacity];
        for (int i = 0; i < array.length; i++) {
            array[i] = i;
        }
        long start = System.currentTimeMillis();
//        insertSort(array);
//        shellSort(array);
//        selectSort(array);
        heapSort(array);
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
    /**
     * 无序的数据
     * @param capacity
     */
    public static void test2(int capacity) {
        int[] array = new int[capacity];
        Random random = new Random();
        for (int i = 0; i < array.length; i++) {
            array[i] = random.nextInt(capacity);
        }
        long start = System.currentTimeMillis();
//        insertSort(array);
//        shellSort(array);
//        selectSort(array);
        heapSort(array);
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
    public static void main(String[] args) {
        test1(10_0000);
        test2(10_0000);
    }

由上图可知堆排序排10万个有序数据和无序数据所需的时间分别为17和15。

🍂7. 冒泡排序🍂

7.1 原理

在无序区间，通过相邻数的比较，将最大的数冒泡到无序区间的最后，持续这个过程，直到数组整体有序

7.2 实现

/**
 * 冒泡排序
 * 时间复杂度：O(N^2) 这个代码 不管是好是坏 都是O(N^2)
 * 空间复杂度：O(1)
 * 稳定性：稳定的排序
 * @param array
 */
public static void bubbleSort(int[] array) {
    for (int i = 0; i < array.length - 1; i++) {
        for (int j = 0; j < array.length - 1 -i; j++) {
            if (array[j] > array[j + 1]) {
                swap(array,j,j + 1);
            }
        }
    }
}
/**
 * 冒泡排序
 * 时间复杂度：O(N^2)
 * 有序情况下：O(n)
 * 空间复杂度：O(1)
 * 稳定性：稳定的排序
 * @param array
 */
public static void bubbleSort2(int[] array) {
    for (int i = 0; i < array.length - 1; i++) {
        boolean flg = false;
        for (int j = 0; j < array.length - 1 -i; j++) {
            if (array[j] > array[j + 1]) {
                swap(array,j,j + 1);
                flg = true;
            }
        }
        if (flg == false) {
            break;
        }
    }
}
public static void main(String[] args) {
    int[] array = {12,5,8,13,29,3,27,19,12,0,14,25,42,2,7,3};
    bubbleSort2(array);
    System.out.println(Arrays.toString(array));
}

7.3 性能分析

稳定性：稳定

    /**
     * 有序的数据
     * @param capacity
     */
    public static void test1(int capacity) {
        int[] array = new int[capacity];
        for (int i = 0; i < array.length; i++) {
            array[i] = i;
        }
        long start = System.currentTimeMillis();
//        insertSort(array);
//        shellSort(array);
//        selectSort(array);
//        heapSort(array);
        bubbleSort(array);
//        bubbleSort2(array);
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
    /**
     * 无序的数据
     * @param capacity
     */
    public static void test2(int capacity) {
        int[] array = new int[capacity];
        Random random = new Random();
        for (int i = 0; i < array.length; i++) {
            array[i] = random.nextInt(capacity);
        }
        long start = System.currentTimeMillis();
//        insertSort(array);
//        shellSort(array);
//        selectSort(array);
//        heapSort(array);
        bubbleSort(array);
//        bubbleSort2(array);
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
    public static void main(String[] args) {
        test1(10_0000);
        test2(10_0000);
    }

由上图可知普通冒泡排序排10万个有序数据和无序数据所需的时间分别为976和12488。

由上图可知加入了判断逻辑的冒泡排序排10万个有序数据和无序数据所需的时间分别为0和12418。

🍄8. 快速排序（重要）🍄

8.1 原理-总览

从待排序区间选择一个数，作为基准值(pivot)；

Partition: 遍历整个待排序区间，将比基准值小的（可以包含相等的）放到基准值的左边，将比基准值大的（可以包含相等的）放到基准值的右边；

采用分治思想，对左右两个小区间按照同样的方式处理，直到小区间的长度 == 1，代表已经有序，或者小区间的长度 == 0，代表没有数据。

先把start的值放入tmp，end 找比 tmp小的放入空的地方(小的放入数组前面)再看start找，然后start 找比 tmp大的放入空(大的放到数组后面)的地方再看end找，直到end和start相遇，我们将tmp放入空的位置进行下一次循环。

实现：

/**
 * 时间复杂度：
 * 最好：【每次可以均匀分割待排序序列】O(N*log n)
 * 最坏：数据有序 或者逆序的情况 O(N^2)
 * 空间复杂度：
 * 最好：O(log n)
 * 最坏：O(n)   单分支的一棵树
 * 稳定性：不稳定
 * @param array  待排序的数组
 */
 //这里的quickSrot函数是为了接口一致而设立的
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 pivot = partition(array,left,right);//基准
    quick(array,left,pivot - 1);//递归左边
    quick(array,pivot + 1,right);//递归右边
}
private static int partition(int[] array,int start,int end) {
    int tmp = array[start];
    while (start < end) {
        while (start < end && array[end] >= tmp) {
            end--;
        }
        //end下标就遇到了小于tmp的值
        array[start] = array[end];
        while (start < end && array[start] <= tmp) {
            start++;
        }
        //start下标就遇到了大于tmp的值
        array[end] = array[start];
    }
    array[start] = tmp;
    return start;
}
public static void main(String[] args) {
    int[] array = {12,5,8,13,29,3,27,19,12,0,14,25,42,2,7,3};
    quickSort(array);
    System.out.println(Arrays.toString(array));
}

8.2 原理-partition(随机取基准)

Hoare 法:

随机取基准法：有可能每次随机的数据，作为基准的时候，也会出现单分支的情况。（随机十分靠运气）

实现：

private static int partition(int[] array, int left, int right) {
    int i = left;
    int j = right;
    int pivot = array[left];
    while (i < j) {
        while (i < j && array[j] >= pivot) {
            j--;
        }
        while (i < j && array[i] <= pivot) {
            i++;
        }
        swap(array, i, j);
    }
    swap(array, i, left);
    return i;
}

挖坑法:

基本思路和Hoare 法一致，只是不再进行交换，而是进行赋值（填坑+挖坑）

实现：

private static int partition(int[] array,int start,int end) {
    int tmp = array[start];
    while (start < end) {
        while (start < end && array[end] >= tmp) {
            end--;
        }
        //end下标就遇到了小于tmp的值
        array[start] = array[end];
        while (start < end && array[start] <= tmp) {
            start++;
        }
        //start下标就遇到了大于tmp的值
        array[end] = array[start];
    }
    array[start] = tmp;
    return start;
}

前后遍历法：

private static int partition(int[] array, int left, int right) {
    int d = left + 1;
    int pivot = array[left];
    for (int i = left + 1; i <= right; i++) {
        if (array[i] < pivot) {
            swap(array, i, d);
            d++;
        }
    }
    swap(array, d, left);
    return d;
}

8.3 性能分析

稳定性：不稳定

8.4 原理-基准值的选择(三数取中法)

1.选择边上（左或者右）

2.随机选择

3.几数取中（例如三数取中）：array[left], array[mid], array[right] 大小是中间的为基准值

以三数取中法我们树的分支就不会出现单分支的情况。

/**
 * 时间复杂度：
 * 最好：【每次可以均匀分割待排序序列】O(N*log n)
 * 最坏：数据有序 或者逆序的情况 O(N^2)
 * 空间复杂度：
 * 最好：O(log n)
 * 最坏：O(n)   单分支的一棵树
 * 稳定性：不稳定
 * @param array  待排序的数组
 */
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 minValIndex = findMidValIndex(array,left,right);
    swap(array,minValIndex,left);
    int pivot = partition(array,left,right,minValIndex);//基准
    quick(array,left,pivot - 1);//递归左边
    quick(array,pivot + 1,right);//递归右边
}
public static int findMidValIndex(int[] array,int start,int end) {
    int mid = start + ((end - start) >>> 1);
    if (array[start] < array[start]) {
        if (array[mid] < array[start]) {
            return start;
        } else if (array[mid] > array[end]) {
            return end;
        } else {
            return mid;
        }
    } else {
        if (array[mid] > array[start]) {
            return start;
        } else if (array[mid] < array[end]) {
            return end;
        } else {
            return mid;
        }
    }
}
private static int partition(int[] array,int start,int end,int minValIndex) {
    int tmp = array[minValIndex];
    while (start < end) {
        while (start < end && array[end] >= tmp) {
            end--;
        }
        //end下标就遇到了小于tmp的值
        array[start] = array[end];
        while (start < end && array[start] <= tmp) {
            start++;
        }
        //start下标就遇到了大于tmp的值
        array[end] = array[start];
    }
    array[start] = tmp;
    return start;
}
public static void main(String[] args) {
    int[] array = {12,5,8,13,29,3,27,19,12,0,14,25,42,2,7,3};
    quickSort(array);
    System.out.println(Arrays.toString(array));
}

8.5 原理-非递归分支

import java.util.*;
private static int partition(int[] array,int start,int end) {
    int tmp = array[start];
    while (start < end) {
        while (start < end && array[end] >= tmp) {
            end--;
        }
        //end下标就遇到了小于tmp的值
        array[start] = array[end];
        while (start < end && array[start] <= tmp) {
            start++;
        }
        //start下标就遇到了大于tmp的值
        array[end] = array[start];
    }
    array[start] = tmp;
    return start;
}
public static void quickSort(int[] array) {
    Stack<Integer> stack = new Stack<>();
    int left = 0;
    int right = array.length - 1;
    int pivot = partition(array,left,right);
    if (pivot > left + 1) {
        //左边有2个元素
        stack.push(left);
        stack.push(pivot - 1);
    }
    if (pivot < right - 1) {
        //右边有2个元素
        stack.push(pivot + 1);
        stack.push(right);
    }
    while (!stack.isEmpty()) {
        right = stack.pop();
        left = stack.pop();
        pivot = partition(array,left,right);
        if (pivot > left + 1) {
            //左边有2个元素
            stack.push(left);
            stack.push(pivot - 1);
        }
        if (pivot < right - 1) {
            //右边有2个元素
            stack.push(pivot + 1);
            stack.push(right);
        }
    }
}
public static void main(String[] args) {
    int[] array = {12,5,8,13,29,3,27,19,12,0,14,25,42,2,7,3};
    quickSort(array);
    System.out.println(Arrays.toString(array));
}

8.6 优化总结

1.选择基准值很重要，通常使用几数取中法

2.partition 过程中把和基准值相等的数也选择出来

3.待排序区间小于一个阈值时（例如 48），使用直接插入排序

8.7 总结

1.在待排序区间选择一个基准值

2.1.选择左边或者右边
2.随机选取
3.几数取中法

3.做 partition，使得小的数在左，大的数在右
4.1.hoare
2.挖坑
3.前后遍历
4.将基准值相等的也选择出来（了解）
5.分治处理左右两个小区间，直到小区间数目小于一个阈值，使用插入排序

🌵9. 归并排序（重要）🌵

9.1 原理-总览

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide andConquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

9.2 原理-合并两个有序数组

例如int[] array1 = [1,6,7,10];和int[] array2 = [2,3,4,9];

/**
 * @param array1 有序的
 * @param array2 有序的
 * @return 合成之后的数组
 */
public static int[] mergeArray(int[] array1,int[] array2) {
    //注意判断参数
    int[] tmp = new int[array1.length + array2.length];
    int s1 = 0;
    int e1 = array1.length - 1;
    int s2 = 0;
    int e2 = array2.length - 1;
    int i = 0;
    while (s1 <= e1 && s2 <= e2) {
        if (array1[s1] <= array2[s2]) {
            tmp[i++] = array1[s1++];
        } else {
            tmp[i++] = array2[s2++];
        }
    }
    while (s1 <= e1) {
        tmp[i++] = array1[s1++];
    }
    while (s2 <= e2) {
        tmp[i++] = array2[s2++];
    }
    return tmp;
}
public static void main(String[] args) {
    int[] array1 = {1,7,11,12,15,19};
    int[] array2 = {1,2,7,7,11,13,14,17,18};
    int[] regular = mergeArray(array1,array2);
    System.out.println(Arrays.toString(regular));
}

9.3 实现

/**
 * 归并排序
 * 时间复杂度：O(N * log N)
 * 空间复杂度：O(N)
 * 稳定性：稳定
 * 如果 array[s1] <= array[s2]  不取等号  那么就是不稳定的排序
 *
 * 学过的排序只有三个是稳定的：
 * 冒泡  插入  归并
 * @param array
 */
public static void mergeSort(int[] array) {
    mergeSortInternal(array,0,array.length - 1);
}
private static void mergeSortInternal(int[] array,int low,int high) {
    if (low >= high) {
        return;
    }
    //int mid = (low + high) >>> 1;
    int mid = low + ((high - low) >>> 1);
    //左边
    mergeSortInternal(array,low,mid);
    //右边
    mergeSortInternal(array,mid + 1,high);
    //归并
    merge(array,low,mid,high);
}
public static void merge(int[] array,int low,int mid,int high) {
    int[] tmp = new int[high - low + 1];
    int s1 = low;
    int e1 = mid;
    int s2 = mid + 1;
    int e2 = high;
    int i = 0;
    while (s1 <= e1 && s2 <= e2) {
        if (array[s1] <= array[s2]) {
            tmp[i++] = array[s1++];
        } else {
            tmp[i++] = array[s2++];
        }
    }
    while (s1 <= e1) {
        tmp[i++] = array[s1++];
    }
    while (s2 <= e2) {
        tmp[i++] = array[s2++];
    }
    //拷贝tmp数组的元素 放到原来的数组array当中
    for (int j = 0; j < i; j++) {
        array[j + low] = tmp[j];
    }
}
public static void main(String[] args) {
    int[] array = {12,5,8,13,29,3,27,19,12,0,14,25,42,2,7,3};
    mergeSort(array);
    System.out.println(Arrays.toString(array));
}

9.4 性能分析

稳定性：稳定

    /**
     * 有序的数据
     * @param capacity
     */
    public static void test1(int capacity) {
        int[] array = new int[capacity];
        for (int i = 0; i < array.length; i++) {
            array[i] = i;
        }
        long start = System.currentTimeMillis();
//        insertSort(array);
//        shellSort(array);
//        selectSort(array);
//        heapSort(array);
//        bubbleSort(array);
//        bubbleSort2(array);
//        quickSort(array);
        mergeSort(array);
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
    /**
     * 无序的数据
     * @param capacity
     */
    public static void test2(int capacity) {
        int[] array = new int[capacity];
        Random random = new Random();
        for (int i = 0; i < array.length; i++) {
            array[i] = random.nextInt(capacity);
        }
        long start = System.currentTimeMillis();
//        insertSort(array);
//        shellSort(array);
//        selectSort(array);
//        heapSort(array);
//        bubbleSort(array);
//        bubbleSort2(array);
//        quickSort(array);
        mergeSort(array);
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
    public static void main(String[] args) {
        test1(10_0000);
        test2(10_0000);
    }

由上图可知归并排序排10万个有序数据和无序数据所需的时间分别为9和13。

9.5 优化总结

在排序过程中重复利用两个数组，减少元素的复制过程

9.6 非递归版本

public static void merge(int[] array,int low,int mid,int high) {
    int[] tmp = new int[high - low + 1];
    int s1 = low;
    int e1 = mid;
    int s2 = mid + 1;
    int e2 = high;
    int i = 0;
    while (s1 <= e1 && s2 <= e2) {
        if (array[s1] <= array[s2]) {
            tmp[i++] = array[s1++];
        } else {
            tmp[i++] = array[s2++];
        }
    }
    while (s1 <= e1) {
        tmp[i++] = array[s1++];
    }
    while (s2 <= e2) {
        tmp[i++] = array[s2++];
    }
    //拷贝tmp数组的元素 放到原来的数组array当中
    for (int j = 0; j < i; j++) {
        array[j + low] = tmp[j];
    }
}
/**
 * 非递归实现归并排序
 *
 * @param array
 */
public static void mergeSort(int[] array) {
   int nums = 1;//每组的数据个数
   while (nums < array.length) {
       //数组每次都要进行遍历
       for (int i = 0; i < array.length; i += nums*2) {
           int left = i;
           int mid = left + nums - 1;
           if (mid >= array.length) {
               mid = array.length - 1;
           }
           int right = mid + nums;
           if (right >= array.length) {
               right = array.length - 1;
           }
           //小标确定之后，进行合并
           merge(array,left,mid,right);
       }
       nums *= 2;
   }
}
public static void main(String[] args) {
    int[] array = {12,5,8,13,29,3,27,19,12,0,14,25,42,2,7,3};
    mergeSort(array);
    System.out.println(Arrays.toString(array));
}

9.7 海量数据的排序问题

内部排序：排序过程需要在内存等内部存储进行的排序

外部排序：排序过程需要在磁盘等外部存储进行的排序

前提：内存只有 1G，需要排序的数据有 100G

因为内存中因为无法把所有数据全部放下，所以需要外部排序(磁盘上排序)，而归并排序是最常用的外部排序

先把文件切分成 200 份，每个 512 M

分别对 512 M 排序，因为内存已经可以放的下，所以任意排序方式都可以

进行 200 路归并，同时对 200 份有序文件做归并过程，最终结果就有序了

🌴10. 排序总结🌴

测试各大排序的时间代码：

    /**
     * 有序的数据
     * @param capacity
     */
    public static void test1(int capacity) {
        int[] array = new int[capacity];
        for (int i = 0; i < array.length; i++) {
            array[i] = i;
        }
        long start = System.currentTimeMillis();
        insertSort(array);
        shellSort(array);
        selectSort(array);
        heapSort(array);
        bubbleSort(array);
        bubbleSort2(array);
        quickSort(array);
        mergeSort(array);
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
    /**
     * 无序的数据
     * @param capacity
     */
    public static void test2(int capacity) {
        int[] array = new int[capacity];
        Random random = new Random();
        for (int i = 0; i < array.length; i++) {
            array[i] = random.nextInt(capacity);
        }
        long start = System.currentTimeMillis();
        insertSort(array);
        shellSort(array);
        selectSort(array);
        heapSort(array);
        bubbleSort(array);
        bubbleSort2(array);
        quickSort(array);
        mergeSort(array);
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
    public static void main7(String[] args) {
        test1(10_0000);
        test2(10_0000);
    }

1、确定计数数组的大小

2、这个计数排序，适合用在 0-99 范围

a、求数组的最大值maxVal 最小是minVal

maxVal - minVal + 1 = 数组的长度

b、count[array[i]-minVal]

/**
 * 计数牌序
 * 时间复杂度：O(N)
 * 空间复杂度：O(M)M:代表当前数据的范围：900-999
 * 稳定性：当前代码是不稳定的，但是本质是稳定的
 * 一般适用于 有n个数，数据范围是0-n之间的
 * @param array
 */
public static void countingSort(int[] array) {
    int maxVal = array[0];
    int minVal = array[0];
    for (int i = 1; i < array.length; i++) {
        if (array[i] < minVal) {
            minVal = array[i];
        }
        if (array[i] > maxVal) {
            maxVal = array[i];
        }
    }
    //说明已经找到了最大值和最小值
    int[] count = new int[maxVal - minVal + 1];//默认都是0
    //统计array数组当中，每个数据出现的次数 例如最大值为8  最小值为1  数组长度从1到8 即8-1+1 = 8
    for (int i = 0; i < array.length; i++) {
        int index = array[i];
        //为了空间的合理使用 这里需要index-minVal  防止923-900
        count[index - minVal]++;
    }
    //说明在计数数组当中，已经把array数组当中，每个数据出现的次数已经统计好了
    //接下来，只需要，遍历计数数组，把数据写回array
    int indexArray = 0;
    for (int i = 0; i < count.length; i++) {
        while (count[i] > 0) {
            //这里一定要加minVal，因为不一定就是i出现了count[i]
            array[indexArray] = i + minVal;
            count[i]--;//拷贝一个之后，次数就少一个
            indexArray++;//下标得向后移动
        }
    }
}
public static void main(String[] args) {
    int[] array = {12,5,8,13,29,3,27,19,12,0,14,25,42,2,7,3};
    countingSort(array);
    System.out.println(Arrays.toString(array));
}

首先我们创建10个桶

按照他们的个位数对应的数字分别放入各个桶中

然后按照0~9的顺序将他们依次拿出来，这样他们的个位数就有顺序了

按照他们的十位数对应的数字分别放入各个桶中

然后按照0~9的顺序将他们依次拿出来，这样他们的个位数和十位数就都有顺序了

按照他们的百位数对应的数字分别放入各个桶中

然后按照0~9的顺序将他们依次拿出来，这样他们的个位数和十位数和百位数就都有顺序了

感谢各位读者的阅读，本文章有任何错误都可以在评论区发表你们的意见，我会对文章进行改正的。如果本文章对你有帮助请动一动你们敏捷的小手点一点赞，你的每一次鼓励都是作者创作的动力哦！😘

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Java排序

🐾1. 概念🐾

1.1 排序

1.2 稳定性（重要）

1.3 应用

💐2. 七大基于比较的排序比-总览💐

🌸3. 插入排序🌸

3.1 直接插入排序-原理

3.2 实现

3.3 性能分析

3.4 折半插入排序（了解）

🌷4. 希尔排序🌷

4.1 原理

4.2 实现

4.3 性能分析

🍀5. 选择排序🍀

5.1 直接选择排序-原理

5.2 实现

5.3 性能分析

5.4 双向选择排序（了解）

🌻6. 堆排序🌻

6.1 原理

6.2 实现

6.3 性能分析

🍂7. 冒泡排序🍂

7.1 原理

7.2 实现

7.3 性能分析

🍄8. 快速排序（重要）🍄

8.1 原理-总览

8.2 原理-partition(随机取基准)

8.3 性能分析

8.4 原理-基准值的选择(三数取中法)

8.5 原理-非递归分支

8.6 优化总结

8.7 总结

9.2 原理-合并两个有序数组

9.3 实现

9.4 性能分析

9.5 优化总结

9.6 非递归版本

9.7 海量数据的排序问题

热门文章

最新文章

相关课程

相关电子书

相关实验场景