JAVA几种常见的排序算法（冒泡、选择、插入、希尔、快速）

JAVA几种常见的排序算法（冒泡、选择、插入、希尔、快速）

如下：

/**
 *   选择排序算法
 *     a、将第一个值看成最小值
 *
 * 　　b、然后和后续的比较找出最小值和下标
 *
 * 　　c、交换本次遍历的起始值和最小值
 *
 * 　　d、说明：每次遍历的时候，将前面找出的最小值，看成一个有序的列表，后面的看成无序的列表，然后每次遍历无序列表找出最小值。
 *
 * 　　e、代码实现
 */
public static int[] selection(int[] arr){

    int temp;
    for (int i = 0; i < arr.length; i++){
        for (int j = i; j < arr.length; j++){
            if (arr[i] > arr[j]){
                temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
    }
    return arr;
}

/**
 *   插入排序算法
 *     a、默认从第二个数据开始比较。
 *
 * 　　b、如果第二个数据比第一个小，则交换。然后在用第三个数据比较，如果比前面小，则插入（狡猾）。否则，退出循环
 *
 * 　　c、说明：默认将第一数据看成有序列表，后面无序的列表循环每一个数据，如果比前面的数据小则插入（交换）。否则退出。
 *
 * 　　d、代码实现
 */
public static int[] insert(int[] arr){
    int temp;
    for (int i = 1; i < arr.length; i++){
        for (int j = i; j > 0; j--){
            if (arr[j-1] > arr[j]){
                temp = arr[j-1];
                arr[j-1] = arr[j];
                arr[j] = temp;
            }
        }
    }
    return arr;
}

/**
 *   希尔排序算法
 *     a、基本上和插入排序一样的道理
 *
 * 　　b、不一样的地方在于，每次循环的步长，通过减半的方式来实现
 *
 * 　　c、说明：基本原理和插入排序类似，不一样的地方在于。通过间隔多个数据来进行插入排序。
 *
 * 　　d、代码实现
 */
public static int[] Hill(int[] arr){

    for (int step = arr.length/2; step > 0; step /= 2){
        for (int i = 0; i < arr.length&&(i+step < arr.length); i++){
            if (arr[i] > arr[i+step]){
                int temp = arr[i];
                arr[i] = arr[i+step];
                arr[i+step] = temp;
            }
        }
    }
    return arr;
}

/**
     *   冒泡排序算法
     *     a、冒泡排序，是通过每一次遍历获取最大/最小值
     *
     * 　　b、将最大值/最小值放在尾部/头部
     *
     * 　　c、然后除开最大值/最小值，剩下的数据在进行遍历获取最大/最小值
     *
     * 　　d、代码实现
     */
    public static int[] bubbling(int[] arr){
        int temp;
        for (int i = 0; i < arr.length; i++){
            for(int j = 0; j < arr.length-1-i;){
                if (arr[j] > arr[j++]){
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        return arr;
    }

/**
     *   快速排序算法
     *     a、确认列表第一个数据为中间值，第一个值看成空缺（低指针空缺）。
     *
     * 　　b、然后在剩下的队列中，看成有左右两个指针（高低）。
     *
     * 　　c、开始高指针向左移动，如果遇到小于中间值的数据，则将这个数据赋值到低指针空缺，并且将高指针的数据看成空缺值（高指针空缺）。然后先向右移动一下低指针，并且切换低指针移动。
     *
     * 　　d、当低指针移动到大于中间值的时候，赋值到高指针空缺的地方。然后先高指针向左移动，并且切换高指针移动。重复c、d操作。
     *
     * 　　e、直到高指针和低指针相等时退出，并且将中间值赋值给对应指针位置。
     *
     * 　　f、然后将中间值的左右两边看成行的列表，进行快速排序操作。
     *
     * 　　g、代码实现
     */
    public static void Rapid(int[] array, int left, int right) {
        if (left > right) {
            return;
        }
        // base中存放基准数
        int base = array[left];
        int i = left, j = right;
        while (i != j) {
            // 顺序很重要，先从右边开始往左找，直到找到比base值小的数
            while (array[j] >= base && i < j) {
                j--;
            }

            // 再从左往右边找，直到找到比base值大的数
            while (array[i] <= base && i < j) {
                i++;
            }

            // 上面的循环结束表示找到了位置或者(i>=j)了，交换两个数在数组中的位置
            if (i < j) {
                int tmp = array[i];
                array[i] = array[j];
                array[j] = tmp;
            }
        }

        // 将基准数放到中间的位置（基准数归位）
        array[left] = array[i];
        array[i] = base;

        // 递归，继续向基准的左右两边执行和上面同样的操作
        // i的索引处为上面已确定好的基准值的位置，无需再处理
        Rapid(array, left, i - 1);
        Rapid(array, i + 1, right);
    }
    
[快速排序参考网址](https://www.cnblogs.com/captainad/p/10999697.html)


**测试过几个测试用例都没有问题，如果逻辑有问题可以告诉我，共同学习！！！**