排序算法（四）快速排序

快速排序是一种交换排序（ Nlog2N）最坏情况（O(N2)）

 

它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分：分割点左边都是比它小的数，右边都是比它大的数。

然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

详细的图解往往比大堆的文字更有说明力，所以直接上图：

上图中，演示了快速排序的处理过程：

初始状态为一组无序的数组：2、4、5、1、3。

经过以上操作步骤后，完成了第一次的排序，得到新的数组：1、2、5、4、3。

新的数组中，以2为分割点，左边都是比2小的数，右边都是比2大的数。

因为2已经在数组中找到了合适的位置，所以不用再动。

2左边的数组只有一个元素1，所以显然不用再排序，位置也被确定。（注：这种情况时，left指针和right指针显然是重合的。因此在代码中，我们可以通过设置判定条件left必须小于right，如果不满足，则不用排序了）。

而对于2右边的数组5、4、3，设置left指向5，right指向3，开始继续重复图中的一、二、三、四步骤，对新的数组进行排序。

public int division(int[] list, int left, int right) {

    // 以最左边的数(left)为基准

    int base = list[left];

    while (left < right) {

        // 从序列右端开始，向左遍历，直到找到小于base的数

        while (left < right && list[right] >= base)

            right--;

        // 找到了比base小的元素，将这个元素放到最左边的位置

        list[left] = list[right];

 

        // 从序列左端开始，向右遍历，直到找到大于base的数

        while (left < right && list[left] <= base)

            left++;

        // 找到了比base大的元素，将这个元素放到最右边的位置

        list[right] = list[left];

    }

 

    // 最后将base放到left位置。此时，left位置的左侧数值应该都比left小；

    // 而left位置的右侧数值应该都比left大。

    list[left] = base;

    return left;

}

 

private void quickSort(int[] list, int left, int right) {

 

    // 左下标一定小于右下标，否则就越界了

    if (left < right) {

        // 对数组进行分割，取出下次分割的基准标号

        int base = division(list, left, right);

 

        System.out.format("base = %d:\t", list[base]);

        printPart(list, left, right);

 

        // 对“基准标号“左侧的一组数值进行递归的切割，以至于将这些数值完整的排序

        quickSort(list, left, base - 1);

 

        // 对“基准标号“右侧的一组数值进行递归的切割，以至于将这些数值完整的排序

        quickSort(list, base + 1, right);

    }

}

下面是可运行例子

package sortarith;

import java.util.Arrays;
/*一、快速排序的基本思想：
        　　快速排序使用了分治的思想，通过一趟排序将待排序列分割成两部分，
           其中一部分记录的关键字均比另一部分记录的关键字小。之后分别对
           这两部分记录继续进行排序，以达到整个序列有序的目的。

        二、快速排序的三个步骤
        1) 选择基准：在待排序列中，按照某种方式挑出一个元素，作为 “基准”（pivot）；

        2) 分割操作：以该基准在序列中的实际位置，把序列分成两个子序列。如果为升序，则此时，
        在基准左边的元素都比该基准小，在基准右边的元素都比基准大；而基准则在排序后正确的位置上。

        3) 递归地对两个序列进行快速排序，直到序列为空或者只有一个元素；*/
public class QuickSort {
    public static void main(String[] args) {
        int[] arr = {9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
        quickSort(arr, 0, arr.length - 1);
        System.out.println("排序结果：" + Arrays.toString(arr));
    }

    /**
     * @param arr
     * @param left  左指针
     * @param right 右指针
     */
    public static void quickSort(int[] arr, int left, int right) {
        if (left < right) {
            //获取枢纽值，并将其放在当前待处理序列末尾
            dealPivot(arr, left, right);
            //枢纽值被放在序列末尾
            int pivot = right - 1;
            //左指针
            int i = left;
            //右指针
            int j = right - 1;
            while (true) {
                while (arr[++i] < arr[pivot]) {
                }
                while (j > left && arr[--j] > arr[pivot]) {
                }
                if (i < j) {
                    swap(arr, i, j);
                } else {
                    break;
                }
            }
            if (i < right) {
                swap(arr, i, right - 1);
            }
            quickSort(arr, left, i - 1);
            quickSort(arr, i + 1, right);
        }

    }

    /**
     * 处理枢纽值
     *
     * @param arr
     * @param left
     * @param right
     */
    public static void dealPivot(int[] arr, int left, int right) {
        int mid = (left + right) / 2;
        if (arr[left] > arr[mid]) {
            swap(arr, left, mid);
        }
        if (arr[left] > arr[right]) {
            swap(arr, left, right);
        }
        if (arr[right] < arr[mid]) {
            swap(arr, right, mid);
        }
        swap(arr, right - 1, mid);
    }

    /**
     * 交换元素通用处理
     *
     * @param arr
     * @param a
     * @param b
     */
    private static void swap(int[] arr, int a, int b) {
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }
}