Java排序算法 [归并排序]

package cn.com.dom4j.sort;

import java.util.Arrays;

public class Test2 {

    /**
     归并排序
        这个算法的基本操作是合并两个已排序的表. 因为这两个表示已排序的, 所以若将输出放到第三个表中, 则该算法可以通过一趟排序来完成
        1. 合并两个已排序的表的时间显然是线性的, 因为最多进行 N-1 次比较, 其中 N是元素的总数
        2. 该算法是经典的分治(divide-and-conquer)策略, 他将问题分(divide)成一些小的问题, 然后递归求解,
           而治(conquer)的阶段则将分的阶段解得的各个答案修补在一起. 分而治之是递归非常有效的用法
        (注: 当将数组分解到仅有一个项时, 该子数组便是有序的, 便可以进行合并操作, 这是一个基准情形)

     */
    public static <AnyType extends Comparable<? super AnyType>> void mergeSort(AnyType[] a) {

        // 产生一个临时数组, 用以存储已经排序好的序列, 每次比较将较小的数先放到临时数组中, 最后在对应位置将元素拷贝至原数组
        AnyType[] tmpArray = (AnyType[]) new Comparable[a.length];

        // 递归分解并将子数组排序的例程
        mergeSort(a, tmpArray, 0, a.length - 1);

    }

    /**
     * 将数组均分成两个较小的数组, 并对分解过后的数组进行排序
     *
     * @param a 原始的数组
     * @param tmpArray 临时数组, 用于存放比较过程中已经排序好的子序列
     * @param left 子序列的起始索引
     * @param right 子序列的结束位置索引
     * @param <AnyType> 实现的 Comparable接口的类或其子类
     */
    private static <AnyType extends Comparable<? super AnyType>> void mergeSort(AnyType[] a, AnyType[] tmpArray, int left, int right) {

        // 保证子数组至少有两个元素
        if (left < right) {

            int center = (left + right) / 2;
            // 分解数组
            mergeSort(a, tmpArray, left, center);
            mergeSort(a, tmpArray, center + 1, right);
            // 合并的主例程
            merge(a, tmpArray, left, center + 1, right);
        }
    }

    /**
     * 将两个已经排序好的子序列( A和 B)合并, 并放到原始数组中的正确位置
     *
     * @param a 原始数组
     * @param tmpArray 临时数组, 用于存放比较过程中产生的已排序的子序列
     * @param leftPos A序列的起始索引, A序列的结束索引通过 rightPos - 1来计算  (两个序列均是 左开又开 [])
     * @param rightPos B序列的起始索引
     * @param rightEnd B序列的结束索引
     * @param <AnyType> 实现了 Comparable接口的类型或其子类
     */
    private static <AnyType extends Comparable<? super AnyType>> void merge(AnyType[] a, AnyType[] tmpArray, int leftPos, int rightPos, int rightEnd) {

        int leftEnd = rightPos - 1;
        int tmpPos = leftPos;
        int numElements = rightEnd - leftPos + 1;

        // 将子数组的起始索引暂存起来, 用于数组拷贝   (因为: leftPos在比较时, 会发生变化(向后推进))
        int fromIndex = leftPos;

        // 两个序列均没有比较完的情况
        while (leftPos <= leftEnd && rightPos <= rightEnd) {

            if (a[leftPos].compareTo(a[rightPos]) <= 0) {
                tmpArray[tmpPos++] = a[leftPos++];
            } else {
                tmpArray[tmpPos++] = a[rightPos++];
            }
        }

        // A序列已经比较完, 将 B序列中的剩余元素拷贝至临时数组
        while (leftPos <= leftEnd) {
            tmpArray[tmpPos++] = a[leftPos++];
        }

        // B序列已经比较完, 将 A序列中的剩余元素拷贝至临时数组
        while (rightPos <= rightEnd) {
            tmpArray[tmpPos++] = a[rightPos++];
        }

        // 将两个子序列的元素存储到原始数组中 (对临时数组相应区间进行拷贝)
        for (int i = 0; i < numElements; i++, rightEnd--) {
            a[rightEnd] = tmpArray[rightEnd];
        }

        // 也可以通过如下方式进行数组拷贝
        System.arraycopy(tmpArray, fromIndex, a, fromIndex, numElements);
    }
}