算法——快速排序

踏踏实实学算法，从今天开始，从现在开始。

快速排序的思想：每次递归选择一个桩，取其值（int pivot = array[pivotIndex]），从数组末尾向前寻找第一个小于该值pivot的元素将其放到桩处（记录该位置为high），从数组开始向后寻找第一个大于该值pivot的元素将其放到high处，再反复从后面往前寻找小于pivot的元素和从前往后寻找大于pivot的元素，直到两者相遇位置（low >= high 则本次划分循环结束），最后讲pivot放到low处（做人要低调！实际放到high处也行！哈哈哈）。每次递归结束，pivot左边的元素均小于pivot，pivot右边的元素均大于pivot。总的递归结束后，数组实现排序。

桩值选择：选择每次递归数组的第一个元素（简单版本采取该方式，适合数组元素随机）。但不建议使用使用该方式，如果数组元素已经有序或逆序，使用本方式将会十分浪费时间。

桩值选择优化：
1. 一种安全的选择：选择数组中间元素（实现也很简单，讲中间元素与第一个元素交换，再选择第一个元素作为桩值），安全合理但却有些消极。
2. 最好的选择是选择数组的中值，能够很好地均分数组。但计算中值会降低算法效率，所以选择一个估计值：选择array[start], array[mid]和array[end]的中值作为桩值。

其他优化：数组长度小于10（根据不用情况来估计一个数值）时采用插入排序，效果会比较好。

public class QuickSort {
    private static int CUTOFF = 10; // 阈值，当数组长度小于该值时用插入排序
    // 稍微复杂
    public static void quickSort(int[] array, int start, int end) {
        if (start + CUTOFF > end) {
            InsertionSort.sort(array);
        } else {
            int mid = (start + end)/2;
            // sort array[start],[mid],[end]
            // 采用三个元素的中值划分，中值为array[mid]
            if (array[mid] < array[start]) {
                swapTwoEle(array, start, mid);
            }
            if (array[end] < array[start]) {
                swapTwoEle(array, start, end);
            }
            if (array[end] < array[mid]) {
                swapTwoEle(array, mid, end);
            }

            // 将桩值与array[end-1]交换，因为array[end]>array[mid],减少一次比较(不交换也可以正确执行)
            swapTwoEle(array, mid, end-1);
            int pivot = array[end-1];

            int low,high;
            for (low = start, high = end-1; ; ) {
                while (array[low++] < pivot)
                    ;
                while (array[high--] > pivot)
                    ;
                if (low >= high) {
                    break;
                }
                swapTwoEle(array, low, high);
            }
            swapTwoEle(array, low, end-1);      
            quickSort(array, start, low-1);
            quickSort(array, low+1, end);
        }
    }

    private static void swapTwoEle(int[] array, int index1, int index2) {
        int temp = array[index1];
        array[index1] = array[index2];
        array[index2] = temp;
    }

    // 简单版本
    public static void sort(int[] array, int start, int end) {
        if (start < end) {
            int low = start;
            int high = end;
//          int mid = (low + high)/2;// 选择array[mid]作为桩值
//          int temp = array[mid];
//          array[mid] = array[start];
//          array[start] = temp;
            int pivot = array[start]; // 以数组第一个值作为轴
            while (low < high) {
                // 从后往前找找到一个小于轴的值，填到low处
                while (low < high && array[high] > pivot)
                    high--;
                array[low] = array[high];
                // 从前往后找找到一个大于轴的值，填到high处
                while (low < high && array[low] < pivot)
                    low++;
                array[high] = array[low];
            }
            array[low] = pivot;
            sort(array, start, low-1);
            sort(array, low+1, end);
        }
    }

    public static void main(String[] args) {
        int[] array = {0,9,8,7,6,5,4,3,2,1,11,22,33,44,55,66,77,88,99};
//      QuickSort.quickSort(array, 0, array.length-1);
        QuickSort.sort(array, 0, array.length-1);
        for (int i = 0; i < array.length; i++)
            System.out.print(array[i] + " ");
    }
}

如果本博客对你有一定帮助，客官请留下你的脚步吧…