java之归并排序

算法思想

利用分治法的思想，将两个已排好序的数组合并成一个数组从而达到整个数组有序的目的。

具体操作

假设有如下数组：Integer[] intArray={1,3,2,5,4,6};我们从中间将intArray分成两个部分，在分别将这两部分继续从中间划分，直到当前部分只剩下两个元素，然后进行合并。合并的思想是将该部分左边的位置到中间位置以及中间位置到右边位置通过判断大小，依次将小的元素复制到一个另外一个数组，最后再将备用数组复制会原数组即达到了排序的目的。

源码

public class Sort {

    public static void main(String[] args) {
        Integer[] intArray={1,3,2,5,4,6};
        System.out.println("排序前数组为：");
        print(intArray);
        Integer[] intBackupArray=new Integer[intArray.length];
        mergeSort(intArray, intBackupArray,0, intArray.length-1);
        System.out.println("排序后数组为：");
        print(intArray);

        String[] strArray={"a","d","f","c"};
        System.out.println("排序前数组为：");
        print(strArray);
        String[] strBackupArray=new String[strArray.length];
        System.out.println("排序后数组为：");
        mergeSort(strArray, strBackupArray,0, strArray.length-1);
        print(strArray);

        Float[] floatArray={5.9f,-1.2f,7f,3.9f};
        System.out.println("排序前数组为：");
        print(floatArray);
        System.out.println("排序后数组为：");
        Float[] floatBackupArray=new Float[floatArray.length];
        mergeSort(floatArray, floatBackupArray,0, floatArray.length-1);
        print(floatArray);

    }

    /**
     * 打印输出数组
     * @param array
     */
    public static <T extends Comparable<? super T>> void print(T[] array){
        for(int i=0;i<array.length;i++){
            System.out.print(array[i]+" ");
        }
        System.out.println();
    }


    /**
     * 二路归并排序
     * @param array 待排序的数组
     * @param left 起始位置
     * @param right 末位置
     */
    public static <T extends Comparable<? super T>> void  mergeSort(T[] array,T[] backupArray,int left,int right){
        if(left<right){
            int middle=(left+right)/2;
            mergeSort(array,backupArray, left, middle);
            mergeSort(array,backupArray, middle+1, right);
            merge(array,backupArray,left,right,middle);
            copy(array, backupArray, left, right);


        }
    }

    /**
     * 将数组合并
     * @param array 数组
     * @param left 起始位置
     * @param right 末位置
     * @param middle 中间位置
     */
    public static  <T extends Comparable<? super T>> void merge(T[] array,T[] backupArray,int left,int right,int middle){
        //合并array[left--middle]和array[middle+1--right]到backupArray
        int i=left;
        int j=middle+1;
        int k=left;
        while(i<=middle&&j<=right){
            if(array[i].compareTo(array[j])<=0){
                backupArray[k++]=array[i++];
            }else{
                backupArray[k++]=array[j++];
            }
        }
        if(i>middle){
            for(int q=j;q<=right;q++)
                backupArray[k++]=array[q];
        }else{
            for(int q=i;q<=middle;q++)
                backupArray[k++]=array[q];
        }

    }

    /**
     * 将数组复制会原数组
     * @param array 原数组
     * @param backupArray 备份数组
     * @param left 起始位置
     * @param right 末位置
     */
    public static <T extends Comparable<? super T>> void copy(T[] array,T[] backupArray,int left,int right){
        for(int i=left;i<=right;i++){
            array[i]=backupArray[i];
        }
    }
}

实验结果