排序算法之快速排序

该算法在数组中选择一个称为主元的元素（pivot），将数组分为两部分，使得第一部分中的所有元素都小于或等于主元，第二部分中的所有元素都大于主元。对第一部分递归地应用快速排序，然后对第二部分递归的使用快速排序算法

public class testQuickSort {

    public static void quickSort(int[] list) {
        quickSort(list, 0, list.length - 1);
    }

    private static void quickSort(int[] list, int first, int last) {
        if (last > first) {
            int pivotIndex = partition(list, first, last);
            quickSort(list, first, pivotIndex - 1);
            quickSort(list, pivotIndex + 1, last);
        }
    }

    // find pivot,Partition the array list(first...last)
    private static int partition(int[] list, int first, int last) {
        // choose the first elements as the pivot
        int pivot = list[first];
        // index for forward search
        int low = first + 1;
        // index for backward search
        int high = last;
        while (high>low) {
            while (list[low] <= pivot && low <= high) {
                low++;
            }
            while (list[high] > pivot && low <= high) {
                high--;
            }

            if (high > low) {
                int temp = list[high];
                list[high] = list[low];
                list[low] = temp;
            }
        }
        while (high > first && list[high] >= pivot) {
            high--;
        }
        if (pivot > list[high]) {
            list[first] = list[high];
            list[high] = pivot;
            return high;
        } else {
            return first;
        }
    }

    public static void main(String[] args) {
        int[] list = { 2, 3, 2, 5, 6, 1, -2, 3, 14, 12 };
        quickSort(list);
        for (int i = 0; i < list.length; i++) {
            System.out.print(list[i] + " ");
        }
    }
}

方法partition使用主元划分为数组list[first...last]，将子数组的第一个元素选为主元，在出事情况下，low指向字数组的第二个元素，而high指向子数组中最后一个元素。

快排时间：

　　最坏情况下，划分由n个元素构成的数组需进行n次比较和n次移动。因此划分时间为O(N)，每次主元会将数组划分为一个大的子数组和一个空数组。这个大的子规模是在上次划分的字数组的规模上减一，该算法需要(n-1)+(n-2)+...+2+1=O(n*n)

　　最佳情况下，每次主元都将数组划分为规模大致相等的两部分。T(n) = T(n/2) + T(n/2) + n

　　　　　　T(n) = O(n*logn)