Java实现常见排序算法（一）

在开发过程中使用得比较多的算法就是排序算法和查找算法了，今天先盘点一下常见的排序算法中的两个大类交换排序和插入排序。

交换排序

快速排序

基本思想：用选取的初始值（一般是第一个）将待排序序列分为小于初始值和大于初始值的两部分，然后重复此操作，最终到排序完成。该算法是一个不稳定的算法（如果待排序序列中存在相同的元素，经过排序后他们的相对位置不发生改变那么这个算法就是稳定的排序算法）
空间复杂度最坏为O(n),平均为O($lo{g}_{2}n$)
时间复杂度最坏为O(n²),最好为O(n$lo{g}_{2}n$),平均O(n$lo{g}_{2}n$)
Java实现：

public static int[] quickSort(int[] n, int low, int high) {
        int lowMark = low, highMark = high;
        int record;
        if (low < high) {
            //记录值
            record = n[low];
            while (lowMark != highMark) {
                //高位指针偏移
                while (lowMark < highMark && n[highMark] >= record) {
                    highMark--;
                }
                //交换元素
                n[lowMark] = n[highMark];
                //低位指针偏移
                while (lowMark < highMark && n[lowMark] <= record) {
                    lowMark++;
                }
                //交换元素
                n[highMark] = n[lowMark];
            }
            //将记录值写到最后低位指针的位置
            n[lowMark] = record;
            //两边分别进行排序操作
            quickSort(n, low, lowMark - 1);
            quickSort(n, lowMark + 1, high);
        }
        return n;
    }

冒泡排序

基本思想：设待排序的序列长度为n，从前往后（或者从后往前）两两比较相邻元素的值，根据自己需要升序或者降序交换两两元素的位置，直到整个序列比较完成，称为一趟冒泡排序，执行完n-1趟冒泡即可将所有元素排好。该算法是一个稳定的算法。
空间复杂度为O(1)
时间复杂度最坏为O(n²),最好为O(n),平均为O(n²)
Java实现：

//update 2020-05-12 以前笔误写错了
public static int[] bubbleSort(int[] nums) {
        int temp;
        for (int i = 0; i < nums.length-1; i++) {
            for (int j = 0; j < nums.length-1-i; j++) {
                if (nums[j] < nums[j+1]) {
                    temp = nums[j];
                    nums[j] = nums[j+1];
                    nums[j+1] = temp;
                }
            }
        }
        return nums;
    }

插入排序

直接插入排序

基本思想：将元素分为有序区[0…i-1]和无序区[i…n-1],将R[i]插入到[0…i-1]中，并且使插入后的区域有序。当一个元素序列越接近有序，性能越好。该算法是一个稳定的算法。
空间复杂度为O(1)
时间复杂度最坏为O(n²)，最好为O(n)，平均为O(n²)
Java实现：

public static int[] insertSort(int[] n) {
        int i, j, guard;
        for (i = 1; i < n.length; i++) {
            //如果i位置的数比他前面的数小，则进行遍历查找应该在有序数组中的插入位置
            if (n[i] < n[i - 1]) {
                //更换哨兵
                guard = n[i];
                //从后向前查找
                for (j = i - 1; j >= 0; j--) {
                    //j位置如果大于哨兵，就交换当前查询数和比较数的位置
                    if (n[j] > guard) {
                        n[j + 1] = n[j];
                    } else {
                        break;
                    }
                }
                //将哨兵位置放进去
                n[j + 1] = guard;
            }
        }
        return n;
    }

折半插入排序

基本思想：排序思想和直接插入排序一致，区别在于折半插入排序在将元素插入到有序区时使用的是二分查找，可以减少关键字间的比较次数。该算法是一个稳定的算法。
空间复杂度为O(1)
时间复杂度平均为O(n²)
Java实现：

private static int[] halfInsertSort(int[] n) {
        int i, j, low, high, mid, guard;
        for (i = 1; i < n.length; i++) {
            guard = n[i];
            low = 0;
            high = i - 1;
            //与直接插入排序类似，只是查找插入位置时使用了二分查找
            while (low <= high) {
                mid = (low + high) / 2;
                if (n[mid] > guard) {
                    high = mid - 1;
                } else {
                    low = mid + 1;
                }
            }
            for (j = i - 1; j >= high + 1; j--) {
                n[j + 1] = n[j];
            }
            n[high + 1] = guard;
        }
        return n;
    }

希尔排序

基本思想：将待排序元素按下标进行增量分组，对每一组的元素采用直接插入排序，随着增量逐渐减小，所分成的组所含的元素越来越多，直到增量变成了1，所有的元素在一个分组中，即完成了排序。改算法是一个不稳定的算法。
该算法可能不是很好理解，这里举一个例子。
比如我们有[1,3,41,15,6,27,10,62,11,22]这样一个待排序的数组。
首先我们确定一个增量5那么分组信息为[1,27],[3,10],[41,62],[15,11],[6,22]
内部排序后变成了[1,3,41,11,6,27,10,62,15,22]
第二次增量变成3分组信息为[1,11,10,22],[3,6,62],[41,27,15]
内部排序后变成了[1,3,15,10,6,27,11,62,41,22]
第三次增量变成1的即所有元素在一个分组中就成了[1,3,6,10,11,15,22,27,41,62]排序完成。
PS.想要弄清关键词比较次数和记录移动次数与增量选择之间的关系，并给出完整的数学分析，今仍然是数学难题。希尔提出的办法是$d_1=n/2$,$d_{i+1}=$$\lfloor$$d_i$/2$\rfloor$,并且最后一个增量等于1
空间复杂度：O(1)
时间复杂度:O((n^1.3-n²)
Java实现：

private static int[] shellSort(int[] n) {
        // i表示希尔排序中的第n/2+1个元素（或者n/4+1）
        // j表示希尔排序中从0到n/2的元素（n/4）
        // r表示希尔排序中n/2+1或者n/4+1的值
        int i, j, r, tmp;
        // 划组排序
        for (r = n.length / 2; r >= 1; r = r / 2) {
            for (i = r; i < n.length; i++) {
                tmp = n[i];
                j = i - r;
                // 一轮排序
                while (j >= 0 && tmp < n[j]) {
                    n[j + r] = n[j];
                    j -= r;
                }
                n[j + r] = tmp;
            }
        }
        return n;
    }