【数据结构】-快速排序Java实现

快速排序是对冒泡排序的一种改进。
基本思想：通过一趟排序将待排记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，然后递归对这两部分记录进行排序，最终达到整个序列有序。
稳定性：不稳定；
时间复杂度：最好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);
        }
    }

}