七种基于比较的排序算法基本原理及实现

最近刚学习完七种比较常见的基于比较的排序算法，感觉比较重要，所以写个博客记录一下，不多说，开冲。

排序：

排序就是使一串无序的数字经过处理之后变得有序，可以是升序，也可以是降序，算法中的排序主要是排升序。
排序需要考虑的因素：
时间复杂度：算法中的基本执行次数。
空间复杂度：临时占据存储空间大小的量度。衡量一个算法所需要的额外空间。
稳定性：两个相等的数据，如果经过排序后，排序算法能保证其相对位置不发生变化，则我们称该算法是具备稳定性的排序算法。

1.直接插入排序

思想：每一步取一个待排序元素，将这个待排序元素与前面的元素进行比较，插入到合适的位置上，下标后移，直至插入所有的元素。

从下标1开始取是为了确保前面有可以比较的元素。
代码如下：

public void inserSort(int[] array) {
   
    int tmp = 0;//tmp是用来记录每次取的元素的值
    for (int i = 1; i < array.length; i++) {
   
        int j;//j用来表示i下标前面的元素的下标，j的初始值为j=i-1。
        tmp = array[i];
        for (j = i - 1; j >= 0; j--) {
   
            if (array[j] > tmp) {
   //当j下标的元素值大于tmp时，把j下标的值赋给j+1下标
                array[j + 1] = array[j];
            } else {
   
                break;
            }
        }
        array[j + 1] = tmp;//一趟比较完之后，将tmp赋值给j+1下标
    }
}

时间复杂度：
最优情况：待排序数组已经有序了，O(n)。
最坏情况：代码中使用了两个循环嵌套，O(n^2)。
空间复杂度：
申请了一个tmp用于保存每次用于比较的元素，所以为O(1)。
稳定性：是一个稳定的排序方式。
在排序时，数组越趋于有序，直接插入排序的时间复杂度越小。

2.希尔排序

思想：希尔排序的思想与直接插入排序的思想相同，只不过在排序的过程中对数据进行了分组，每一次排完，下一次进行排序时数据更趋近于有序，时间复杂度大大降低。
先分为五组，每组进行直接插入排序。

再分为三组，每组进行直接插入排序。

最后进行一次直接插入排序。
代码如下：

public void shell(int[] array, int gap) {
   
    int tmp;
    for (int i = gap; i < array.length; i++) {
   
        int j;
        tmp = array[i];
        for (j = i - gap; i < array.length; i -= gap) {
   
            if (array[j] > tmp) {
   
                array[j + gap] = array[j];
            } else {
   
                break;
            }
        }
        array[j + gap] = tmp;
    }
}

public void shellSort(int[] array) {
   
    int[] drr = {
   5, 3, 1};//增量序列
    for (int i = 0; i < drr.length; i++) {
   //每组进行直接插入排序
        shell(array, drr[i]);
    }
}

对于分组的规则：应使增量序列中的值没有除1之外的公因子，并且最后一个增量值必须为1。(分组所采取的组数从大到小，都为素数，最后一个数为1，例如上述情况选择531分组，也可以是521分组)。

时间复杂度：
最坏情况：O(n^2)。
最优情况：O(n)。
空间复杂度：O(1)。
稳定性：不稳定的排序。

3.选择排序

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

代码如下：

public void selectSort(int[] array) {
   
    for (int i = 0; i < array.length; i++) {
   
        for (int j = i + 1; j < array.length; j++)