数据结构与算法（JAVA篇）之高级排序_快速排序（三）

/**
 * @author SunnyMoon
 */

/**********
 * 概念介绍：
 * ********
 *处理小划分：
 * 1. 如果使用三数据项取中值的方法取枢纽，这时快速排序算法不能执行三个或者小于三个数据项
 * 的划分规则，这时数字3就为排序算法的切割点。在上一篇中对三个或三个以下的数据排序时
 * 使用手动的方式排序，这种方式实践中不是最好的选择。
 * 2. 处理小划分的另一个选择是使用插入排序，当使用插入排序时可以将划分设定为10或其它任何
 * 数，试验不同的切割点的值以找到最佳的切割点，专家推荐使用9为切割点。对小的子数组使用
 * 插入排序被证时为最快的一种方法。将插入排序和快速排序相结合，可以把快速排序的性能发挥
 * 到极极，本篇程序使用该方法。
 * 4. 第三个选择是对数组整个使用快速排序不考虑处理小划分，当结束时数据基本有序了，然后
 * 使用插入排序对数据排序。因为插入排序对基本有序的数组执行效率很高，许多专家提倡使用
 * 这种方法，但是插入排序对小规模的数据排序很适合，随着数据规模的扩大性能下降明显。
 *
 * 消除递归：
 * 很多人提倡对快速排序算法进行修改，取消递归包括重写算法用栈实践。但是对于现在的
 * 系统来说消除递归所带来的改进不是很明显。
 */
class ArrayIns {

    private long[] theArray;
    private int nElems;

    public ArrayIns(int max) {
        theArray = new long[max];
        nElems = 0;
    }

    public void insert(long value) {
        theArray[nElems] = value;
        nElems++;
    }

    public void display() {
        System.out.print("A=");
        for (int j = 0; j < nElems; j++) {
            System.out.print(theArray[j] + " ");
        }
        System.out.println("");
    }

    /**
     * 快速排序主方法
     */
    public void quickSort() {
        recQuickSort(0, nElems - 1);
    }

    /**
     * 递归调用快速的排序核心方法
     * @param left
     * @param right
     */
    public void recQuickSort(int left, int right) {
        int size = right - left + 1;
        if (size < 10) {
            insertionSort(left, right);
        } else {
            long median = medianOf3(left, right);//三数取中值
            int partition = partitionIt(left, right, median);//三数据取中值作为枢纽进行划分
            recQuickSort(left, partition - 1);//递归排序数组左子元素
            recQuickSort(partition + 1, right);//递归排序数据左子元素
        }
    }

    /**
     * 三数据选中
     * @param left
     * @param right
     * @return
     */
    public long medianOf3(int left, int right) {
        int center = (left + right) / 2;

        if (theArray[left] > theArray[center]) {
            swap(left, center);
        }
        if (theArray[left] > theArray[right]) {
            swap(left, right);
        }
        if (theArray[center] > theArray[right]) {
            swap(center, right);
        }
        swap(center, right - 1);
        return theArray[right - 1];
    }

    /**
     * 交换数据
     * @param dex1
     * @param dex2
     */
    public void swap(int dex1, int dex2) {
        long temp = theArray[dex1];
        theArray[dex1] = theArray[dex2];
        theArray[dex2] = temp;
    }

    /**
     * 根据三数据选中进行划分
     * @param left
     * @param right
     * @param pivot
     * @return
     */
    public int partitionIt(int left, int right, long pivot) {
        int leftPtr = left;//定位到最左元素
        int rightPtr = right - 1;//定位到枢纽

        while (true) {
            while (theArray[++leftPtr] < pivot);//寻找大于枢纽元素
            while (theArray[--rightPtr] > pivot);//寻找小于枢纽元素
            if (leftPtr >= rightPtr) {//确定划分结束退出循环
                break;
            } else {
                swap(leftPtr, rightPtr);//交换需划分的元素
            }
        }
        swap(leftPtr, right - 1);//恢复枢纽到正确位置
        return leftPtr;//返回枢纽
    }

    /**
     * 手动排序
     * @param left
     * @param right
     */

    public void insertionSort(int left, int right) {
        int in, out;//in为内循环指针，out为外循环指针

        for (out = left + 1; out <= right; out++) {
            long temp = theArray[out];//移除当前标记元素到临时变量
            in = out;//定位内循环

            while (in > left && theArray[in - 1] >= temp) {//满足条件时向左移动元素
                theArray[in] = theArray[in - 1];
                --in;
            }
            theArray[in] = temp;//插入当前标记元素到正确位置
        }
    }
}

/**
 * 主类
 */
public class QuickSort3 {

    public static void main(String[] args) {
        int maxSize = 10;
        ArrayIns arr = new ArrayIns(maxSize);
        for (int j = 0; j < maxSize; j++) {//随机生机数据插入数组中
            long n = (int) (java.lang.Math.random() * 99);
            arr.insert(n);
        }
        System.out.println("显示排序前数据");
        arr.display();
        arr.quickSort();
        System.out.println("显示排序后数据");
        arr.display();
    }
}
/**
 * 运行结果：
 * 显示排序前数据
 * A=56 14 50 18 82 58 30 50 60 1
 * 显示排序后数据
 * A=1 14 18 30 50 50 56 58 60 82
 */

/**
 * 总结：
 * 快速排序是常用排序中效率最高的一种排序方式。
 * 但在应用中的一此特殊情况影响他的效率，这不是算法本身的问题，而是如果实现的问题。
 * 三数据项选中方法很好的解决了这样的问题。三数据选中方法不是最好的选择，可以将插入排序
 * 与快速排序相结合的方式解决这样的问题，使快速排序算法发挥到极致。
 */