排序算法（二）：希尔、快速排序的JAVA实现

排序算法（二）：希尔、快速排序的JAVA实现
常见的8大排序算法分类如下：

一：希尔排序

1.1思路

（1）增量gap需要循环来实现，直到增量<1。
（2）在每组操作时，类似冒泡、选择进行排序

1.2代码实现

package test.sort;

import java.util.Arrays;

/**
 * @author shkstart
 * @create 2021-01-09 19:47
 */
public class Shellsort {
    public static void main(String[] args) {
        int[] arr = new int[]{8, 9, 1, 7, 2, 3, 5, 4, 6, 0,111};

        shell(arr);
        System.out.println(Arrays.toString(arr));


    }

    public static void shell(int[] arr) {

        int temp = 0;
        int mm = arr.length / 2;
        while (mm >= 1) {
            for (int i = mm; i < arr.length; i++) {
                for (int j = i - mm; j >= 0; j -= mm) {
                    if (arr[j] > arr[j + mm]) {
                        temp = arr[j];
                        arr[j] = arr[j + mm];
                        arr[j + mm] = temp;
                    }
                }
            }
            mm = mm / 2;
            System.out.println("" + Arrays.toString(arr));
        }
    }

    public static void shell2(int[] arr) {


        int mm = arr.length / 2;
        while (mm >= 1) {
            for (int i = mm; i < arr.length; i++) {
                int j = i;
                int temp = arr[j];
            //    if (arr[j] < arr[j - mm])
                {
                    while ( j - mm>= 0&&temp < arr[j - mm] ) {
                        arr[j] = arr[j - mm];
                        j -= mm;
                    }
                    arr[j] = temp;
                }
            }
            mm = mm / 2;

        }

    }



}

二：快速排序

快速排序，将要排序数据分割成独立两部分，选择一个基准数，其中一部分数据都要比另外一部分小，生成了（2 10 8 5） （22 34 12 28 21 ）。在按照这个做法分别进行新的一轮快速排序，如图示， （2 10 8 5）数列重新进行快排，以此类推。

2.1思路

（1）以数组下标中间量的数据为基准，从小到大排，左边的数比基准数大或等，右边的数比基准数小（或等），进行交换。需要定义两个下标变量 i j
（2）i==j,退出循环。
（3）非单一数据的生成子数列进行新一轮的快排。

2.2代码实现

package test.sort;

import java.util.Arrays;

/**
 * @author shkstart
 * @create 2021-01-10 11:00
 */
public class Quick {
    public static void main(String[] args) {
        int[] arr = {-9, 78, -0, 23, -567, 23, 32, 0};
        quicksort(arr, 0, arr.length - 1);
        System.out.println(Arrays.toString(arr));
    }
    public static void quicksort(int[] arr, int left, int right) {
        int l = left;
        int r = right;
        int pivot = arr[(left + right) / 2];
        int temp = 0;
        while (l < r) {

            while (arr[l] < pivot) {
                l += 1;
            }

            while (arr[r] > pivot) {
                r -= 1;
            }
            if (l >= r) {
                break;             //遍历到同一个数时退出
            }
            temp = arr[l];
            arr[l] = arr[r];         //若不退出，说明有值需要交换
            arr[r] = temp;

            if (arr[l] == pivot) {        //数组中可能存在与基准值同的数据 或 遍历到基准值
                r--;
            }
            if (arr[r] == pivot) {
                l++;
            }
        }
        if (l == r) {   //为了新一轮的快排，去掉基数值(该值不需要排序)，如上述例子的11，本例的arr[(left + right) / 2];
            l++;
            r--;
        }
        if (left < r) {
            quicksort(arr, left, r);
        }
        if (right > l) {
            quicksort(arr, l, right);
        }
    }
}