十大排序算法——快速排序

public class Quick {
    public static void sort(Comparable[] a) {
        int low = 0;
        int high = a.length - 1;
        sort(a, low, high);
    }
    private static void sort(Comparable[] a, int low, int high) {
        if (high < low) {
            return;
        }
        //对a数组中，从low到high的元素进行切分
        int partition = partition(a, low, high);
        //对左边分组中的元素进行排序
        sort(a,low,partition-1);
        //对右边分组中的元素进行排序
        sort(a,partition+1,high);
    }
    private static int partition(Comparable[] a, int low, int high) {
        Comparable key = a[low];
        int left = low;
        int right = high + 1;
        //进行切分
        while (true) {
            //先从右边往左边扫描，找到一个比基准值小的元素
            while (less(key, a[--right])) {
                if (right == low) {
                    break;
                }
            }
            //再从左往右扫描，找一个比基准值大的元素
            while (less(a[++left], key)) {
                if (left == high) {
                    break;
                }
            }
            if (left >= right) {
                break;
            } else {
                exchange(a, left, right);
            }
        }
        exchange(a,low,right);
        return right;
    }
    //比较v元素是否小于w元素
    private static boolean less(Comparable v,Comparable w){
        return v.compareTo(w)<0;
    }
    //数组元素i和j交换位置
    private static void exchange(Comparable[] a,int i,int j){
        Comparable t=a[i];
        a[i]=a[j];
        a[j]=t;
    }
}
//测试代码
 class Test{
    public static void main(String[] args) {
        Integer[] a={8,4,6,5,7,1,3,6,2};
        Quick.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

public class QuickSort {
    private static void quickSort(int[] arr, int low, int high) {
        if (low < high) {
            // 分区操作，将一个数组分成两个分区，返回分区界限索引
            int index = partition(arr, low, high);
            // 对左分区进行快排
            quickSort(arr, low, index - 1);
            // 对右分区进行快排
            quickSort(arr, index + 1, high);
        }
    }
    private static int partition(int[] arr, int low, int high) {
        int pivot = arr[low];
        while (low < high) {
            // 1、先看右边，依次往左递减
            while (pivot <= arr[high] && low < high) {
                high--;
            }
            // 2、将右侧找到小于基准数的值加入到左边的（坑）位置， 左指针向中间移动一个位置
            if (low < high) {
                arr[low] = arr[high];
                low++;
            }
            // 3、再看左边，依次往右递增
            while (pivot > arr[low] && low < high) {
                low++;
            }
            // 4、将左侧找到的打印等于基准值的值加入到右边的坑中，右指针向中间移动一个位置 high--
            if (low < high) {
                arr[high] = arr[low];
                high--;
            }
        }
        // 最后将基准为与low和high相等位置的数字交换
        arr[low] = pivot;
        // 返回基准值的位置索引
        return low;
    }
    public static void main(String[] args) {
        int[] arr = {1,28,3,21,11,7,6,18};
        quickSort(arr, 0, arr.length - 1);
        System.out.println(Arrays.toString(arr));
    }
}