内部排序算法系列---快速排序

实现思路：从待排序的数据序列中任取一个数据作为分界值，所有比它小的数据元素一律放在左边，所有比它大的数据元素一律放在右边。经过一趟下来，该序列形成左右两个子序列，左边序列中数据元素的值都是比分界值小，右边子序列比分界值大。接下来对左右两个子序列进行递归，直到每个子序列的元素只剩一个，排序完成。

import java.util.Arrays;

/**
 * @author stefanie zhao
 * @date 2014-9-29 下午02:53:38
 */
public class QuickSort {

    public static void main(String[] args) {
        //DataWrap类见其他算法系列blog中
        DataWrap[] data = { new DataWrap(23, ""), new DataWrap(13, ""), new DataWrap(43, ""), new DataWrap(9, ""),
                new DataWrap(3, ""), new DataWrap(34, "") };
        System.out.println("before sort: \n" + Arrays.toString(data));
        quickSort(data);
        System.out.println("after sort: \n" + Arrays.toString(data));
    }

    private static void swap(DataWrap[] data, int i, int j) {
        DataWrap tmp = data[i];
        data[i] = data[j];
        data[j] = tmp;
    }

    private static void subSort(DataWrap[] data, int start, int end) {
        // 需要排序
        if (start < end) {
            // 以第一个值为分界值
            DataWrap base = data[start];
            // i从左边开始搜索，搜索大于分界值的元素的索引
            int i = start;
            // j从右边开始搜索，搜索小于分界值的元素索引
            int j = end + 1;
            while (true) {
                // 找到大于分界值的元素索引，或i已经到了end处
                while (i < end && data[++i].compareTo(base) <= 0);
                // 找到小于分界值的元素索引，或j已经到了start处
                while (j > start && data[--j].compareTo(base) >= 0);
                if (i < j)
                    swap(data, i, j);
                else
                    break;
            }
            // 交换分界值和j
            swap(data, start, j);
            // 递归左子序列
            subSort(data, start, j - 1);
            // 递归右子序列
            subSort(data, j + 1, end);
        }
    }

    public static void quickSort(DataWrap[] data) {
        subSort(data, 0, data.length - 1);
    }

}

快速排序的时间效率很好，因为它每趟能确定的元素呈指数增长。

快速排序需要使用递归，而递归使用栈，因此它的空间效率为O(log2(n))。