Java快速排序

快速排序是排序算法中很重要，而且也是使用很广泛的一种排序算法。它的思想也归并排序有点类似，都是需要分区，并对每个分区进行排序，然后对整个分区进行排序。

排序流程图

排序思想

1.先对整个数组进行分区。
2.在分区时便可以对数组进行一定程度的排序。
3.从待排序的区间中选择一个数，作为目前整个区间的基准值。
4.遍历整个待排序区间，将比基准值小的（可以包括相等的）放在基准值的左边，将比基准值打的（也可以包括相等的）放到基准值的右边。
5.采用分治的思想，对左右的两个小区间也使用同样的方式处理，直到小区间的长度为1，代表已经有序，或者小区间的长度为0，代表没有数据。
6.重复上述的流程，直到整个数组排序完成。

排序代码

public static void quickSort(int[] arr){
	//对数组进行快速排序，区间为闭区间
    quickSortInternal(arr, 0, arr.length - 1);
}

//对数组分区
private static void quickSortInternal(int[] arr, int l, int r) {
	//将当前的数组进行快速排序
    int p = partition(arr, l, r);
    //对左区间进行快速排序
    quickSortInternal(arr, l, p);
    //对右区间进行快速排序
    quickSortInternal(arr, p + 1, r);
}

//对分好区的子数组进行快速排序
private static int partition(int[] arr, int l, int r) {
	//用v来记录基准值
    int v = arr[l];
    //j为小于基准值的区间
    int j = l;
    for (int i = l + 1; i <= r; i++) {
    	//若小于基准值，则将数字移动到小于的区间中
        if (arr[i] < v){
            swap(arr, i, ++j);
        }
    }
    //将基准值交换到相应的位置
    swap(arr, l, j);
    return j;
}

private static void swap(int[] arr, int i, int j){
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

代码改进1——防止栈溢出和加入随机数

代码改进思想

1.上述的代码在较少的数据处理时，一般不会有什么问题，但当遇到很多的数据时，就可能会出现栈溢出的问题。于是可以在处理较少的数据时，直接使用插入排序（插入排序在近乎有序时，效率很高），减少对函数的调用。
2.在进行快速排序选择基准值时，可以使用随机数，使得排序会更加有效。

改进代码

public static void quickSort(int[] arr){
    quickSortInternal(arr, 0, arr.length - 1);
}

//对数组分区
private static void quickSortInternal(int[] arr, int l, int r) {
	//在较少的数据时，使用插入排序，
    if (r - l <= 15){
        insertSort(arr, l, r);
        return;
    }
    int p = partition(arr, l, r);
    quickSortInternal(arr, l, p);
    quickSortInternal(arr, p + 1, r);
}

//对分好区的子数组进行快速排序
private static int partition(int[] arr, int l, int r) {
	//加入随机数，使得此次的排序会更加有效
    int randomIndex = random.nextInt(l, r);
    swap(arr, l, randomIndex);
    int v = arr[l];
    int j = l;
    for (int i = l + 1; i <= r; i++) {
        if (arr[i] < v){
            swap(arr, i, ++j);
        }
    }
    swap(arr, l, j);
    return j;
}

private static void swap(int[] arr, int i, int j){
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

public static void insertSort(int[] arr,int l,int r){
    for (int i = l + 1; i <= r; i++) {
        for (int j = i; j > l && arr[j] < arr[j - 1]; j--){
            swap(arr, j - 1, j);
        }
    }
}

代码改进2——二路快排

代码改进流程图

代码改进思想

之前的代码都是一次遍历只能选择一个数放入到对应的区间，于是我们便可以想到是否可以一次遍历，选出两个数来放入到对应的区间，以提高遍历的效率
1.使用左右两个指针，分别指向待排序数据的起始和结尾的位置，左指针向右遍历，右指针向左遍历。
2.当左指针找到一个大于基准值的数，且右指针找到第一个小于基准值的数时，两数据进行交换。
3.重复上述的流程，直到两指针相遇，则遍历结束。
4.将基准值交换到相应的位置。

改进代码

public static void quickSort2(int[] arr){
    quickSortInternal2(arr, 0, arr.length - 1);
}

private static void quickSortInternal2(int[] arr, int l, int r) {
    if (l - r <= 15){
        insertSort(arr, l, r);
        return;
    }
    int p = partition2(arr, l, r);
    quickSortInternal2(arr, l, p);
    quickSortInternal2(arr, p + 1, r);
}

private static int partition2(int[] arr, int l, int r) {
    int randomIndex = random.nextInt(l, r);
    swap(arr, l, randomIndex);
    int v = arr[l];
    //左指针
    int m = l;
    //右指针
    int n = r;
    while (m < n){
    	//左指针一直遍历，直到找到一个大于基准值的数
        while (m < n && arr[m + 1] < v){
            ++m;
        }
        //右指针一直遍历，直到找到一个小于基准值的数
        while (m < n && arr[n - 1] > v){
            --n;
        }
        //交换左右指针所指向的数
        swap(arr, m, n);
        ++m;
        --n;
    }
    swap(arr, l, m);
    return m;
}

private static void swap(int[] arr, int i, int j){
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

public static void insertSort(int[] arr,int l,int r){
    for (int i = l + 1; i <= r; i++) {
        for (int j = i; j > l && arr[j] < arr[j - 1]; j--){
            swap(arr, j - 1, j);
        }
    }
}