排序算法-交换排序之快速排序

和归并排序一样，快速排序也是一种分治的递归算法。
快速排序的思想是：选取一个枢纽元，将比枢纽元小的元素放枢纽元前面，把比枢纽元小的元素放后面，然后将前面的集合，后面的集合，重复之前的步骤。
枢纽元的选取是一门学问，我们要将枢纽元的尽量选取为集合中间值，使得枢纽元两边的元素量能更加均匀，避免大小不等的递归调用。我们将第一个元素，中值元素，最后一个元素作比较，取大小在三者中间的元素作为枢纽元。
在下面的代码中，我们对快速排序进行了优化，首先是枢纽元的选取，其次，对于小数组（N<=20），快速排序不如插入排序。所以我们在元素量小于20时，采用了插入排序。同时避免了当集合为一个或者两个元素时，选取枢纽元没有三个元素的情况，当然也给编程增加了方便。
代码：

package com.creat.sort;import org.junit.Test;/** * Created by whz on 2017/8/23. */public class QuickSort {    @Test    public void testSort(){        Integer[] array = new Integer[]{10,54,78,789,30,310,354,365,312,412,564,474,499,574,400,55,47,123,156,126,50,100,20,41,414,33,454,1000,40,70};        sort(array);        for(int i = 0; i < array.length; i++){            System.out.print(array[i]+" ");        }        System.out.println();    }    public static <T extends Comparable<? super T>> void sort(T[] array){        sort(array,0, array.length-1);    }    public static <T extends Comparable<? super T>> void insertSort(T[] array,int left, int right){        int length = array.length;        T temp = null;        for(int i = 1+left; i <= right; i++){            for(int n = i-1; n >= left; n--){                if(array[n].compareTo(array[n+1]) > 0){                    temp = array[n];                    array[n] = array[n+1];                    array[n+1] = temp;                }else {                    break;                }            }        }    }    private static <T extends Comparable<? super T>> void sort(T[] array,int left, int right){        if(right - left +1 > 20){            T pivot = getPivot(array, left, right);            int l = left;            int r = right - 2;            while(l < r){                while(array[l].compareTo(pivot) < 0){                    l++;                }                while(array[r].compareTo(pivot) > 0 ){                    r--;                }                if(l < r){                    swap(array, l, r);                }else {                    break;                }            }            swap(array, l, right - 1);            sort(array, left, l-1);            sort(array, l+1, right);        }else {            insertSort(array, left, right);        }    }    private static <T extends Comparable<? super T>> T getPivot(T[] array,int left, int right){        int middle = (left + right)/2;        if(array[left].compareTo(array[middle]) > 0){            swap(array, left, middle);        }        if(array[left].compareTo(array[right]) > 0 ){            swap(array, left, right);        }        if(array[middle].compareTo(array[right]) > 0){            swap(array, middle, right);        }        swap(array, middle, right-1);        return array[right-1];    }    private static <T extends Comparable<? super T>> void swap(T[] array,int one, int anthor){        T temp = array[one];        array[one] = array[anthor];        array[anthor] = temp;    }}

快速排序的时间复杂度最好和平均为O(Nlog2N),最坏为O(N^2)。