【东东学数据结构】快速排序

快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n 个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n²)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他Ο(n log n) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实作出来，且在大部分真实世界的资料，可以决定设计的选择，减少所需时间的二次方项之可能性。

设要排序的数组是A[0]……A[N-1]，首先任意选取一个数据（通常选用第一个数据）作为关键数据，然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一趟快速排序。然后分别递归的排序关键数据前面和后面两段数据。值得注意的是，快速排序不是一种稳定的排序算法，也就是说，多个相同的值的相对位置也许会在算法结束时产生变动。

在具体实现上，如何吧将所有比它小的数都放到它前面，所有比它大的数都放到它后面是关键。也有不同的版本。先来第一个版本：

import java.util.Arrays;
import java.util.Random;

/**
 * User: laichendong
 * Date: 12-3-14
 * Time: 上午9:57
 */
public class QuickSort {
    private static Random random = new Random();

    public static void main(String[] args) {
        int[] array = {49, 38, 52, 44, 81, 97, 76, 13, 27, 65};
        qsort(array, 0, array.length - 1);
        System.out.println(Arrays.toString(array));
    }

    private static int partionSort(int[] array, int begin, int end) {
        int index = begin + random.nextInt(end - begin + 1);
        int key = array[index];
        swap(array, index, end);
        for (int k = index = begin; k < end; k++) {
            if (array[k] < key) {
                swap(array, index, k);
                index++;
            }
        }
        swap(array, index, end);
        return index;
    }

    private static void qsort(int[] array, int begin, int end) {
        if (begin < end) {
            int index = partionSort(array, begin, end);
            qsort(array, begin, index - 1);
            qsort(array, index, end);
        }
    }

    private static void swap(int[] a, int i, int j) {
        int t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
}

第二个版本：

import java.util.Arrays;
import java.util.Random;

/**
 * User: laichendong
 * Date: 12-3-14
 * Time: 上午9:57
 */
public class QuickSort {
    private static Random random = new Random();

    public static void main(String[] args) {
        int[] array2 = {49, 38, 52, 44, 81, 97, 76, 13, 27, 65};
        qsort2(array2, 0, array2.length - 1);
        System.out.println(Arrays.toString(array2));
    }

    private static void qsort2(int[] array, int begin, int end) {
        if (begin < end) {
            int index = partionSort2(array, begin, end);
            if(begin < end - 1){
                qsort(array, begin, index - 1);
                qsort(array, index, end);
            }
        }
    }

    private static int partionSort2(int[] array, int begin, int end){
        int key = array[begin];
        int i = begin;
        int j = end;
        while (i <= j){
            if(array[j] <= key){
                if(array[i] >= key){
                    swap(array, i, j);
                    j--;
                }else {
                    i++;
                }
            }else{
                j--;
            }
        }
        return i;
    }

    private static void swap(int[] a, int i, int j) {
        int t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
}

推荐使用第一个版本，比较好理解。最后，发一个对应版本二的动画演示：