快速排序算法，是在冒泡排序算法之上，进行改进后的一种算法。其时间复杂度为O(nlogn)，是所有时间复杂度相同的排序算法中性能最好的排序算法。

    快速排序算法的思想是：通过一次排序，将整个无序表以标志位为分割点，划分为相互独立的两个部分，其中一部分的数据都比标志位的值要小，另一部分的数据都比标志位的值要大，然后继续对这两部分数据进行同样的分割操作，直到每一个小部分不可再分之后，所得到的整个序列就是有序序列。

    1. import java.util.Arrays;
    3. /**
    4.  * 快速排序
    5.  * 不稳定排序
    6.  */
    7. public class QuickSort {
    9.     public int[] quickSort(int[] arrays){
    10.         if(null == arrays){
    11.             throw new NullPointerException("arrays is null");
    12.         }
    13.         if(!(arrays.length>0)) {
    14.             return arrays;
    15.         }
    16.         int[] sortArrays = Arrays.copyOf(arrays, arrays.length);
    17.         quickSort(sortArrays,0,sortArrays.length-1);
    18.         return sortArrays;
    19.     }
    21.     private void quickSort(int[] nums,int lowNum,int highNum){
    22.         if(lowNum<highNum){
    23.             //找到中间值（将小于中间值的放前面，大于中间值的放后面）
    24.             int middle = getMiddle(nums, lowNum, highNum);
    25.             //排序小于中间值的部分
    26.             quickSort(nums, lowNum, middle-1);
    27.             //排序大于中间值的部分
    28.             quickSort(nums, middle+1, highNum);
    29.         }
    30.     }
    32.     private int getMiddle(int[] nums,int lowNum,int highNum){
    33.         //取最低位的值作为标志//当然，也可以用最高位作为标志
    34.         //去最低位或者最高位有一个好处，后面就会看到
    35.         int temp = nums[lowNum];
    36.         //在未找到标志最终存储的位置时，一直循环
    37.         //直到lowNum = highNum的时候
    38.         //就是标志最终存储的位置
    39.         while(lowNum<highNum){
    40.             /**
    41.              *  在数组两个值比较的时候，没有等于号，会出现死循环   1,3,4,2,4    temp = 4,lowNum=2,highNum=4,这样就会一直死循环
    42.              *  没有 end>start ，则会出现数组下标越界的情况
    43.              * */
    45.             //因为我们取的最低为做标志，即低于temp的值有一个空格
    46.             //则可以先放一个高位上低于temp的值到该空格中
    47.             //第一个while循环：从最高位向前遍历，直到遇到第一个小于temp的位置
    48.                 //放在lowNum下标的位置，即将小于temp的值放在temp的前面
    49.             while(lowNum<highNum&&temp<=nums[highNum]){
    50.                 highNum--;
    51.             }
    52.             nums[lowNum] = nums[highNum];
    53.             //第二个while循环：从最低位向后遍历，直到遇到第一个大于temp的位置，
    54.                 //因为前面已经将highNum位置的值放在了lowNum下标处
    55.                 //则可以将该大于temp的值放在highNum下标的位置
    56.                 //--不是最高位，是经过第一个while循环之后，空出来的位置
    57.             while(lowNum<highNum&&temp>=nums[lowNum]){
    58.                 lowNum++;
    59.             }
    60.             nums[highNum] = nums[lowNum];
    61.             //然后进入while的括号条件中进行lowNum与highNum比较
    62.         }
    63.         //执行到这里  lowNum和highNum值相等，即找到了标志temp的在最最终排好序的数组中的位置
    64.         nums[lowNum] = temp;
    65.         return lowNum;
    66.     }
    68.     public void println(int [] a) {
    69.         for(int x:a) {
    70.             System.out.print(" "+x);
    71.         }
    72.         System.out.println("");
    73.     }
    75.     public static void main(String[] args) {
    76.         int [] a = {2,99,89,87,58,96,94,56,45,12,35,20,44,77,18};
    77.         QuickSort quickSort = new QuickSort();
    78.         quickSort.quickSort(a);
    79.     }
    80. }