【排序算法】02归并排序

接上文：【排序算法】01冒泡排序

归并排序运用分治思想来解决排序问题。

往ArraySorterUtils工具类中添加归并排序的实现，代码如下：

package org.liws1.sort;

import java.util.Arrays;
import java.util.Comparator;

/**
 * 数组的排序,这里统一做升序排序
 */
public class ArraySorterUtils {

    public static class MergeSorter implements IArraySorter{
        
        @Override public <T extends Comparable<T>> void sort(T[] list) {
            if(list != null && list.length > 1) {
                mergeLoop(list, 0, list.length - 1);
            }
        }

        @Override public <T> void sort(T[] list, Comparator<T> comp) {
            // 实现省略，与sort(T[] list)没差
        }
        
        /**
         * 归并排序的递归逻辑部分：
         *    使srcDatas的"[start~end]片段"有序
         * @param srcDatas
         * @param start
         * @param end
         */
        private static <T extends Comparable<T>> void mergeLoop(T[] srcDatas, int start, int end) {
            if(start != end){
                int middle = (start + end) / 2;
                mergeLoop(srcDatas, start, middle);
                mergeLoop(srcDatas, middle + 1, end);
                merge(srcDatas, start, middle, end);
            }
        }

        /**
         * 归并排序的基本操作: 
         *    将两个位置相邻的 有序记录子序列 srcDatas[start~middle] 和 srcDatas[middle+1~end]
         * 归并为一个有序记录序列 srcDatas[start~end] 。
         * @param srcDatas
         * @param start
         * @param middle
         * @param end
         */
        private static <T extends Comparable<T>> void merge(T[] srcDatas, int start, int middle, int end) {
            // 创建1个临时数组，用于临时存放归并后的有序记录序列
            @SuppressWarnings("unchecked")
            T[] tempArr = (T[]) new Comparable[srcDatas.length];    
            
            // 1、归并两个子序列 srcDatas[start~middle] 和  srcDatas[middle+1~end] 到 destDatas[start~end]
            int p = start;         // p遍历srcDatas[start~middle]
            int q = middle + 1; // q遍历srcDatas[middle+1~end]
            int r = start;         // r指向destDatas[start~end]
            for (; p <= middle && q <= end; r++) {
                if (srcDatas[p].compareTo(srcDatas[q]) <= 0) {
                    tempArr[r] = srcDatas[p++];
                } else {
                    tempArr[r] = srcDatas[q++];
                }
            }
            // 将两个有序记录子序列中剩下的记录也复制到destDatas【下面两个while循环只可能走其中一个】
            while(p <= middle){
                tempArr[r++] = srcDatas[p++];
            }
            while(q <= end){
                tempArr[r++] = srcDatas[q++];
            }
            
            // 2、将临时数组中[start~end]的内容拷贝回原数组相应位置中  
            for (int i = start; i <= end; i++) {
                srcDatas[i] = tempArr[i];
            }
        }

    }

}

测试代码如下：

package org.liws1.sort;

import java.util.Arrays;
import org.junit.Test;

public class _Test {

    private Integer[] datas = { 30, 1, 29, 2, 28, 3, 27, 4, 26, 5, 25, 6, 24, 7,
            23, 8, 22, 9, 21, 10, 20, 19, 15, 18, 12, 17, 11, 16, 14, 13 };
    
    @Test public void testMerge(){
        new ArraySorterUtils.MergeSorter().sort(datas);
        System.out.println(Arrays.toString(datas));
    } // out:[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30]
}