排序笔记_6（三向切分的快速排序）

package com.chapter_two;

import java.util.Random;

/***
 * 三向切分的快速排序
 * 
 * @author LuodiJack
 * 
 *         思想：
 * 
 *         他从从左到右遍历数组一次，维护一个指针 lt 使得 a[low .. lt-1]中的元素都小于 v,
 * 
 *         一个指针 gt 使得 a[gt+1 .. high]中的元素都大于 v ，
 * 
 *         一个指针 i 使得a[lt .. i-1] 中的元素都等于 v, a[i .. high]中的元素都还未确定，
 * 
 *         一开始 i 和 low 都相等， 我们使用 Comparable接口对a[i]进行三向比较来直接处理以下情况：
 * 
 *         ① a[i] 小于 v, 将a[lt]和a[i]交换， 将 lt 和 i 加一；
 * 
 *         ② a[i] 大于 v, 将a[gt]和a[i]交换，将 gt 减一；
 * 
 *         ③ a[i] 等于 v, 将 i 加一；
 * 
 *         这些操作都会保证数组元素不变且缩小 gt-i 的值（这样循环才会结束）。
 * 
 *         另外，除非和切分元素相等，其他元素都会被交换。
 * 
 *         能将和切分元素相等的元素归位，这样就它们就uhUI被包含在递归调用处理的子数组中，
 * 
 *         对于存在大量重复元素的数组，这种方法比标准排序的效率高的多。
 */

public class Quick3Way {
    @SuppressWarnings("rawtypes")
    private static void shuffle(Comparable[] a) {// 将数组a的元素重新打乱顺序
        for (int i = 0; i < a.length; i++) {
            int index = new Random().nextInt(a.length);
            Comparable tmp = a[index];
            a[index] = a[i];
            a[i] = tmp;
        }
    }

    @SuppressWarnings("rawtypes")
    public static void sort(Comparable[] a) {
        shuffle(a);// 消除对输入的依赖 P186 比如说第一、二次或者每一次都从最小的元素切分，
                    // 则每次只会移除一个元素，效率很低。
        sort(a, 0, a.length - 1);
    }

    @SuppressWarnings({ "rawtypes", "unchecked" })
    private static void sort(Comparable[] a, int low, int high) {
        if (high <= low) {
            return;
        }
        int lt = low;
        int gt = high;
        int i = low + 1;
        Comparable v = a[low];
        while (i <= gt) {
            int cmp = a[i].compareTo(v);
            if (cmp < 0) {
                Template.exch(a, i++, lt++);
            } else if (cmp > 0) {
                Template.exch(a, i, gt--);
            } else {
                i++;
            }
        }
        sort(a, low, lt - 1);
        sort(a, gt + 1, high);
    }
}