【常见排序算法】插入排序、希尔排序、选择排序、堆排序、冒泡排序

---

前言

如图是对基于比较排序算法的归纳，其余还有非基于比较的排序如计数排序、基数排序和桶排序。
这里主要介绍前五种（插入、希尔、选择、堆排序、冒泡）排序比较简单的排序。

---

一、插入排序

插入排序是一种简单直观的排序算法，其基本思想是将待排序的序列分为已排序和未排序两部分，每次从未排序的部分中选取一个元素插入到已排序的部分中，直到所有元素都被插入完毕。

具体来说，对于一个待排序的序列，插入排序的过程如下：

1、将第一个元素视为已排序部分
2、依次将未排序部分中的元素插入到已排序部分中，使得已排序部分仍然有序
3、直到未排序部分中所有元素都被插入完毕，排序完成
在插入排序的过程中，每次插入一个元素时，需要将其与已排序部分中的元素进行比较，并找到插入位置。为了将元素插入到正确位置，需要将已排序部分中的元素向后移动，以便腾出插入位置。

由于插入排序在每次插入时都需要将已排序部分中的元素向后移动，因此在最坏情况下，插入排序的时间复杂度为O(n^2)。但是，在实际应用中，插入排序常常被用作快速排序等其他高级排序算法的辅助排序算法。

对代码来说，从第二个元素开始，每次取tmp保存待排序元素，将待排序元素和它前面的所有元素逐一比较，直到确定插入位置

    //直接插入排序
    public static void insectSort(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;
        }
    }

解读：tmp为待插入元素，内层循环往前遍历，大于tmp的元素应该往后走一位；反之，由于当前已经有序，前面元素本就有序，不需要继续比较

---

二、希尔排序

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

插入排序的分组是跳跃性的分组：1. 希尔排序是对直接插入排序的优化。
2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。
3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算

    //希尔排序
    public static void shellSwap(int[] array) {
        int gap = array.length / 2;
        while (gap >= 1) {
            shell(array, gap);
            gap /= 2;
        }
    }

    private 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;
        }
    }

解读：代码很简单，和插入排序基本一致。每次插入排序根据gap的不同取值和每次缩小而更趋近于有序，直到gap=1插入排序后使得最终有序。

---

三、选择排序

选择排序非常直观好理解，但是效率很低，实际中基本不使用。

基本思想：
每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完 。

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

    public static void selectSort(int[] array) {
        //记录最小值下标，从左到右依次有序
        for (int i = 0; i < array.length; i++) {
            int minIdx = i;
            for (int j = i + 1; j < array.length; j++) {
                if (array[j] < array[minIdx]) {
                    minIdx = j;
                }
            }
            swap(array, i, minIdx);
        }
    }
    
    private static void swap(int[] array, int i, int j) {
        int tmp = array[i];
        array[i] = array[j];
        array[j] = tmp;
    }

解读：非常简单直观，每次记录最小值下标，使从左至右依次有序。但是效率低的问题从代码上看也很明显，下面有一个优化后的选择排序。

    //选择排序优化
    public static void selectSortOptimization(int[] array) {
        int left = 0;
        int right = array.length - 1;
        while (left < right) {
            int minIdx = left;
            int maxIdx = right;
            //同时找最大值和最小值，分别放到right和left的位置，即排序后的最大最小位置
            for (int i = left; i <= right; i++) {
                if (array[i] < array[minIdx]) {
                    minIdx = i;
                }
                if (array[i] > array[maxIdx]) {
                    maxIdx = i;
                }
            }
            swap(array, left, minIdx);
            //如果最大值在left，此时left和最小值位置交换，最小值位置存放最大值
            if (left == maxIdx) {
                maxIdx = minIdx;
            }
            swap(array, right, maxIdx);
            left++;
            right--;
        }
    }
    
    private static void swap(int[] array, int i, int j) {
        int tmp = array[i];
        array[i] = array[j];
        array[j] = tmp;
    }

解读：每次遍历同时记录最小和最大值，分别放在首和尾处，每次遍历就使两个元素完全有序。

特殊情况：

• 由于最左侧（left）位置是待交换的最小值位置，当最大值在这个位置时，会导致最大值先被minIdx位置的元素交换。
  所以在交换该次最大值时，最大值位置在minIdx，即maxIdx应更新为minIdx

---

四、堆排序

堆排序在上一篇博客【优先级队列（堆）】中已有介绍。
总结两步：
1、创建大顶堆
2、依次将堆顶元素和堆底交换，使堆底有序，再对堆顶向下调整

这里给出完整代码：

    /**
     * 堆排序:
     * 时间复杂度：O(N*logN)
     * 空间复杂度：O(1)
     * 稳定性：不稳定的排序
     */
    public static void headSort(int[] array) {
        //1.创建大顶堆
        createHeap(array);
        //2.每次将堆顶元素和堆底交换，再对堆顶向下调整
        int end = array.length - 1;
        while (end > 0) {
            swap(array, 0, end);//从后往前放最大值
            siftDown(array, 0, end - 1);
            end--;
        }
    }

    private static void createHeap(int[] array) {
        //从最后的父节点开始，逐个向下调整
        for (int parent = (array.length - 1 - 1) / 2; parent >= 0; parent--) {
            siftDown(array, parent, array.length - 1);
        }
    }

    private static void siftDown(int[] array, int parent, int end) {
        int child = parent * 2 + 1;
        while (child <= end) {
            if (child + 1 <= end && array[child + 1] > array[child]) {
                child++;
            }
            if (array[parent] < array[child]) {
                swap(array, parent, child);
                parent = child;
                child = 2 * parent + 1;
            } else {
                break;
            }
        }
    }
    
    private static void swap(int[] array, int i, int j) {
        int tmp = array[i];
        array[i] = array[j];
        array[j] = tmp;
    }

---

五、冒泡排序

冒泡排序是一种非常容易理解的排序，在初学编程时，我们使用的排序就是冒泡排序。
总结一句话：趟数为数组长度-1，每次遍历将一个最大值移动到数组尾部，即从尾到头依次有序。

    //冒泡排序
    public static void bubbleSort(int[] array) {
        //从前往后每次调整一个最大元素到末尾
        for (int i = 0; i < array.length; i++) {
            boolean flag = false;
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j + 1] < array[j]) {
                    swap(array, j, j + 1);
                    flag = true;
                }
            }
            //没交换，表示已经有序
            if (!flag) {
                return;
            }
        }
    }

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

这里做出了一个优化，如果在一趟遍历中一次都没交换，说明这些元素已经有序了。

---

五种排序的力扣OJ通过情况

力扣链接：912.排序数组
除希尔排序和堆排序外，其余3种排序均超出时间限制；

希尔排序：

堆排序：