快速排序的实现及优化（Java）

1-快速排序之单向扫描法

算法思想：两个指针，左侧指针sp确定数组元素小于主元的，右侧指针bigger确定数组元素大于主元的，先划分，然后分别对数组左右两部分递归排序。其中，划分方法为：左侧指针sp从左到右依次扫描，若扫描的元素小于主元，则左侧指针右移；若扫描的元素大于主元，则交换arr[sp]与arr[bigger]，同时右侧指针bigger右移，当sp>bigger时，划分结束。

public class QuickSortDemo {
    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
    public static int partition(int[] arr, int p, int r) {
        int pivot = arr[p];
        int sp = p + 1;
        int bigger = r;
        while (sp <= bigger) {
            if (arr[sp] <= pivot) {
                sp++;
            } else {
                swap(arr, sp, bigger);
                bigger--;
            }
        }
        swap(arr, p, bigger) ;
        return bigger;
    }

    public static void quickSort(int[] arr, int p, int r) {
        if (p < r) {
            int q = partition(arr, p, r);
            quickSort(arr, p, q - 1);
            quickSort(arr, q + 1, r);
        }
    }

    public static void main(String[] args) {
        int[] arr = {2, 1, 3, 5, 4, 7, 6, 9, 8, 10, 0};
        quickSort(arr, 0, arr.length-1) ;
        for(int i=0; i<arr.length; i++){
            System.out.print(arr[i] + " ") ;
        }
    }
}

2-快速排序之双向扫描法

算法思想：头指针left和尾指针right分别从两侧往中间扫描，若头指针left指向的元素小于主元，则头指针left右移，若尾指针指向的元素大于主元，则尾指针right左移，找到左侧比主元大的元素，找到右侧比主元小的元素，二者交换，直至左侧没有比主元大的元素，右侧没有比主元小的元素。

public class QuickSortDemo2 {
    public static void swap(int [] arr, int i, int j){
        int temp = arr[i] ;
            arr[i] = arr[j] ;
            arr[j] = temp ;
    }
    public static int partition(int [] arr, int p, int r){
        int pivot = arr[p] ;
        int left = p + 1 ;
        int right = r ;
        while(left <= right){
            while(arr[left] <= pivot && left <= right){
                left ++ ;
            }
            while(arr[right] >= pivot && left <= right){
                right -- ;
            }
            if(left < right){
                swap(arr, left, right) ;
            }
        }
        swap(arr, right, p) ;
        return right ;
    }
    public static void quickSort(int [] arr, int p, int r){
        if(p < r){
            int q = partition(arr, p, r) ;
            quickSort(arr, p, q-1) ;
            quickSort(arr, q+1, r) ;
        }
    }
    public static void main(String[] args){
        int [] arr = {2,1,4,5,3,8,7,9,6,10,0} ;
        quickSort(arr, 0, arr.length-1) ;
        for(int i=0; i<arr.length; i++){
            System.out.print(arr[i] + " ") ;
        }
    }
}

3-快速排序优化1之三点中值法

优化，在arr[p],arr[r],arr[midValueIndex]之间选择一个作为主元，而不是直接将arr[p]作为主元。

public class QuickSortDemo3 {
    public static void swap(int [] arr, int i, int j){
        int temp = arr[i] ;
        arr[i] = arr[j] ;
        arr[j] = temp ;
    }
    public static int partition(int [] arr, int p, int r){
        //优化，在arr[p],arr[r],arr[midValueIndex]之间选择一个作为主元
        int midIndex = (p + r) >>> 1 ;
        int midValueIndex = -1 ;
        if(arr[p] >= arr[midIndex] && arr[p] <= arr[r]){
            midValueIndex = p ;
        }
        else if(arr[r] >= arr[midIndex] && arr[r] <= arr[p]){
            midValueIndex = r ;
        }
        else{
            midValueIndex = midIndex ;
        }
        swap(arr, midValueIndex, p) ;
        int pivot = arr[p] ;
        int left = p + 1 ;
        int right = r ;
        while(left <= right){
            //left<=right必须写在循环的前面,否则会导致数组越界,则报错
            while(left <= right && arr[left] <= pivot){
                left ++ ;
            }
            while(left <= right && arr[right] >= pivot){
                right -- ;
            }
            if(left < right){
                swap(arr, left, right) ;
            }
        }
        swap(arr, p, right) ;
        return right ;
    }
    public static void quickSort(int [] arr, int p, int r){
        if(p < r){
            int q = partition(arr, p, r) ;
            quickSort(arr, p, q-1) ;
            quickSort(arr, q+1, r) ;
        }
    }
    public static void main(String[] args){
        int [] arr = {2,3,5,1,4,8,7,0,10,9} ;
        quickSort(arr, 0, arr.length-1) ;
        for(int i=0; i<arr.length; i++){
            System.out.print(arr[i] + " ") ;
        }
    }
}

4-快速排序法优化2之绝对中值法

对数组元素进行分组，对每个分组进行插入排序，去分组的中值，如此反复，直至取出数组的绝对中值。使用绝对中值作为主元。

public class QuickSortDemo4 {
    //插入排序,每次从未排序的中选择一个插入到已经排序的队列中
    public static void insertSort(int [] arr, int begin, int end){
        for(int i=begin+1; i<=end; i++){
            int key = arr[i] ;
            int j = i - 1 ;
            while(j>=0 && key < arr[j]){
                arr[j+1] = arr[j] ;
                j-- ;
            }
            arr[j+1] = key ;
        }
    }
    //绝对中值法确定中值元素
    public static int getMedian(int [] arr, int p, int r){
        int size = r - p + 1 ; //数组长度
        int groupSize = (size % 5 == 0) ? (size / 5) : (size / 5 + 1) ; //分组大小
        int [] medians = new int [groupSize] ; //存储各个分组的中值
        int indexOfMedians = 0 ;
        //对每一组进行插入排序
        for(int j=0; j<groupSize; j++){
            //单独处理最后一组，因为最后一组可能不满5个元素
            if(j == groupSize - 1){
                insertSort(arr, p + j * 5, r) ;
                medians[indexOfMedians ++] = arr[(p + j * 5 + r) / 2] ;
            }
            else{
                insertSort(arr, p + j * 5, p + j * 5 + 4) ;
                medians[indexOfMedians ++] = arr[p + j * 5 + 2] ;
            }
        }
        return medians[medians.length / 2] ;
    }
    //交换arr[i]与arr[j]的方法
    public static void swap(int [] arr, int i, int j){
        int temp = arr[i] ;
        arr[i] = arr[j] ;
        arr[j] = temp ;
    }

    /**划分方法，双指针扫描方法，若左侧扫描指针小于等于主元，则左侧指针右移，
     * 若右侧指针大于等于主元，则右侧指针左侧。否则将左右指针所指元素交换，
     * 直至左侧没有大于主元的元素，右侧没有小于主元的元素。
     */

    public static int  partition(int [] arr, int p, int r){
        int midValueIndex = getMedian(arr, p, r) ;
        swap(arr, p, midValueIndex) ;
        int pivot = arr[p] ;
        int left = p + 1 ;
        int right = r ;
        while(left <= right){
            while(left <= right && arr[left] <= pivot){
                left ++ ;
            }
            while(left <= right && arr[right] >= pivot){
                right -- ;
            }
            if(left < right){
                swap(arr, left, right) ;
            }
        }
        swap(arr, p, right) ;
        return right ;
    }
    public static void quickSort(int [] arr, int p, int r){
        if(p < r){
            int q = partition(arr, p, r) ;
            quickSort(arr, p, q-1) ;
            quickSort(arr, q+1, r) ;
        }
    }
    public static void main(String[] args){
        int [] arr = {2,1,3,5,4,9,8,6,0,10,7} ;
        quickSort(arr, 0, arr.length - 1) ;
        for(int i=0; i<arr.length; i++){
            System.out.print(arr[i] + " ") ;
        }
    }
}