快速排序是对冒泡排序的一种改进。
基本思想：通过一趟排序将待排记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，然后递归对这两部分记录进行排序，最终达到整个序列有序。
稳定性：不稳定；
时间复杂度：最好O(nlogn)–最坏O(n*n)–平均O（nlogn）

package org.iti.algorithm;

import java.util.Random;

/** * * @author Tailyou * */
public class ArraySort {
    public static void main(String[] args) {
        int[] array = genArray(8);
        System.out.println("排序前：");
        printArray(array);
        // 快速排序
        quickSort(array,0,array.length - 1);
        System.out.println("排序后：");
        printArray(array);
    }

    /** * 产生数组 * * @return */
    public static int[] genArray(int length) {
        Random random = new Random();
        int[] sort = new int[length];
        for (int i = 0; i < length; i++) {
            sort[i] = random.nextInt(50);
        }
        return sort;
    }

    /** * 打印数组 * * @param sort */
    public static void printArray(int[] sort) {
        for (int i = 0; i < sort.length; i++) {
            if (i == sort.length - 1) {
                System.out.println(sort[i]);
            } else {
                System.out.print(sort[i] + ",");
            }
        }
    }

    /** * 快速排序O(n^2-nlogn) * * @param array * @param left * @param right */
    public static void quickSort(int[] array,int left,int right) {
        int i = left;
        int j = right;
        int middle = array[(i + j) / 2];

        do {
            while (array[i] < middle && i < right)
                i++;
            while (array[j] > middle && j > left)
                j--;

            if (i <= j) {
                int temp = array[j];
                array[j] = array[i];
                array[i] = temp;
                i++;
                j--;
            }

        } while (i <= j);

        if (i < right) {
            quickSort(array,i,right);
        }

        if (j > left) {
            quickSort(array,left,j);
        }
    }

}