【高级排序算法】2、归并排序法的实现-Merge Sort

时间：2021-02-27 10:52:27

简单记录 - bobo老师的玩转算法系列–玩转算法 -高级排序算法

Merge Sort 归并排序

Java实现归并排序

SortTestHelper 排序测试辅助类

package algo;

import java.lang.reflect.Method;

import java.lang.Class;

import java.util.Random;

public class SortTestHelper {

    // SortTestHelper不允许产生任何实例

    private SortTestHelper(){}

    // 生成有n个元素的随机数组,每个元素的随机范围为[rangeL, rangeR]

    public static Integer[] generateRandomArray(int n, int rangeL, int rangeR) {

        assert rangeL <= rangeR;

        Integer[] arr = new Integer[n];

        for (int i = 0; i < n; i++)

            arr[i] = new Integer((int)(Math.random() * (rangeR - rangeL + 1) + rangeL));

        return arr;

    }

    // 生成一个近乎有序的数组

    // 首先生成一个含有[0...n-1]的完全有序数组, 之后随机交换swapTimes对数据

    // swapTimes定义了数组的无序程度:

    // swapTimes == 0 时, 数组完全有序

    // swapTimes 越大, 数组越趋向于无序

    public static Integer[] generateNearlyOrderedArray(int n, int swapTimes){

        Integer[] arr = new Integer[n];

        for( int i = 0 ; i < n ; i ++ )

            arr[i] = new Integer(i);

        for( int i = 0 ; i < swapTimes ; i ++ ){

            int a = (int)(Math.random() * n);

            int b = (int)(Math.random() * n);

            int t = arr[a];

            arr[a] = arr[b];

            arr[b] = t;

        }

        return arr;

    }

    // 打印arr数组的所有内容

    public static void printArray(Object[] arr) {

        for (int i = 0; i < arr.length; i++){

            System.out.print( arr[i] );

            System.out.print( ' ' );

        }

        System.out.println();

        return;

    }

    // 判断arr数组是否有序

    public static boolean isSorted(Comparable[] arr){

        for( int i = 0 ; i < arr.length - 1 ; i ++ )

            if( arr[i].compareTo(arr[i+1]) > 0 )

                return false;

        return true;

    }

    // 测试sortClassName所对应的排序算法排序arr数组所得到结果的正确性和算法运行时间

    public static void testSort(String sortClassName, Comparable[] arr){

        // 通过Java的反射机制，通过排序的类名，运行排序函数

        try{

            // 通过sortClassName获得排序函数的Class对象

            Class sortClass = Class.forName(sortClassName);

            // 通过排序函数的Class对象获得排序方法

            Method sortMethod = sortClass.getMethod("sort",new Class[]{Comparable[].class});

            // 排序参数只有一个，是可比较数组arr

            Object[] params = new Object[]{arr};

            long startTime = System.currentTimeMillis();

            // 调用排序函数

            sortMethod.invoke(null,params);

            long endTime = System.currentTimeMillis();

            assert isSorted( arr );

            System.out.println( sortClass.getSimpleName()+ " : " + (endTime-startTime) + "ms" );

        }

        catch(Exception e){

            e.printStackTrace();

        }

    }

}

归并排序算法实现

MergeSort

package algo;

import java.util.*;

public class MergeSort{

    // 我们的算法类不允许产生任何实例

    private MergeSort(){}

    // 将arr[l...mid]和arr[mid+1...r]两部分进行归并

    private static void merge(Comparable[] arr, int l, int mid, int r) {

        Comparable[] aux = Arrays.copyOfRange(arr, l, r+1);

        // 初始化，i指向左半部分的起始索引位置l；j指向右半部分起始索引位置mid+1

        int i = l, j = mid+1;

        for( int k = l ; k <= r; k ++ ){

            if( i > mid ){  // 如果左半部分元素已经全部处理完毕

                arr[k] = aux[j-l]; j ++;

            }

            else if( j > r ){   // 如果右半部分元素已经全部处理完毕

                arr[k] = aux[i-l]; i ++;

            }

            else if( aux[i-l].compareTo(aux[j-l]) < 0 ){  // 左半部分所指元素 < 右半部分所指元素

                arr[k] = aux[i-l]; i ++;

            }

            else{  // 左半部分所指元素 >= 右半部分所指元素

                arr[k] = aux[j-l]; j ++;

            }

        }

    }

    // 递归使用归并排序,对arr[l...r]的范围进行排序

    private static void sort(Comparable[] arr, int l, int r) {

        if (l >= r)

            return;

        int mid = (l+r)/2;

        sort(arr, l, mid);

        sort(arr, mid + 1, r);

        merge(arr, l, mid, r);

    }

    public static void sort(Comparable[] arr){

        int n = arr.length;

        sort(arr, 0, n-1);

    }

    // 测试MergeSort

    public static void main(String[] args) {

        // Merge Sort是我们学习的第一个O(nlogn)复杂度的算法

        // 可以在1秒之内轻松处理100万数量级的数据

        // 注意：不要轻易尝试使用SelectionSort, InsertionSort或者BubbleSort处理100万级的数据

        // O(n^2)太慢了 算死

        // 否则，你就见识了O(n^2)的算法和O(nlogn)算法的本质差异：）

        int N = 1000000;

        Integer[] arr = SortTestHelper.generateRandomArray(N, 0, 100000);

        SortTestHelper.testSort("algo.MergeSort", arr);

        return;

    }

}

测试百万无序数组，数据范围0到10万 归并还可以。

插入排序就GG了，算不出来，一直在算中。

Result

D:\Environments\jdk-11.0.2\bin\java.exe -javaagent:D:\Java\ideaIU-2019.2.win\lib\idea_rt.jar=3887:D:\Java\ideaIU-2019.2.win\bin -Dfile.encoding=UTF-8 -classpath D:\IdeaProjects\imooc\Play-with-Algorithms\03-Sorting-Advance\out\production\02-Merge-Sort algo.MergeSort

MergeSort : 1330ms

Process finished with exit code 0

还可能呢

归并排序与插入排序比较

InsertionSort

package algo;

        import java.util.*;

public class InsertionSort{

    // 我们的算法类不允许产生任何实例

    private InsertionSort(){}

    public static void sort(Comparable[] arr){

        int n = arr.length;

        for (int i = 0; i < n; i++) {

            Comparable e = arr[i];

            int j = i;

            for( ; j > 0 && arr[j-1].compareTo(e) > 0 ; j--)

                arr[j] = arr[j-1];

            arr[j] = e;

        }

    }

    private static void swap(Object[] arr, int i, int j) {

        Object t = arr[i];

        arr[i] = arr[j];

        arr[j] = t;

    }

    // 测试InsertionSort

    public static void main(String[] args) {

        int N = 10000;

        Integer[] arr = SortTestHelper.generateRandomArray(N, 0, 100000);

        SortTestHelper.testSort("algo.InsertionSort", arr);

        return;

    }

}

比较速率

Main

package algo;

import java.util.Arrays;

public class Main {

    // 比较InsertionSort和MergeSort两种排序算法的性能效率

    // 整体而言, MergeSort的性能最优, 对于近乎有序的数组的特殊情况, 见测试2的详细注释

    public static void main(String[] args) {

        int N = 50000;

        // 测试1 一般测试

        System.out.println("Test for random array, size = " + N + " , random range [0, " + N + "]");

        Integer[] arr1 = SortTestHelper.generateRandomArray(N, 0, N);

        Integer[] arr2 = Arrays.copyOf(arr1, arr1.length);

        SortTestHelper.testSort("algo.InsertionSort", arr1);

        SortTestHelper.testSort("algo.MergeSort", arr2);

        System.out.println();

        // 测试2 测试近乎有序的数组

        // 对于近乎有序的数组, 数组越有序, InsertionSort的时间性能越趋近于O(n)

        // 所以可以尝试, 当swapTimes比较大时, MergeSort更快

        // 但是当swapTimes小到一定程度, InsertionSort变得比MergeSort快

        int swapTimes = 10;

        assert swapTimes >= 0;

        System.out.println("Test for nearly ordered array, size = " + N + " , swap time = " + swapTimes);

        arr1 = SortTestHelper.generateNearlyOrderedArray(N, swapTimes);

        arr2 = Arrays.copyOf(arr1, arr1.length);

        SortTestHelper.testSort("algo.InsertionSort", arr1);

        SortTestHelper.testSort("algo.MergeSort", arr2);

        return;

    }

}

Result

D:\Environments\jdk-11.0.2\bin\java.exe -javaagent:D:\Java\ideaIU-2019.2.win\lib\idea_rt.jar=3916:D:\Java\ideaIU-2019.2.win\bin -Dfile.encoding=UTF-8 -classpath D:\IdeaProjects\imooc\Play-with-Algorithms\03-Sorting-Advance\out\production\02-Merge-Sort algo.Main

Test for random array, size = 50000 , random range [0, 50000]

InsertionSort : 6498ms

MergeSort : 43ms

Test for nearly ordered array, size = 50000 , swap time = 10

InsertionSort : 9ms

MergeSort : 77ms

Process finished with exit code 0

比较InsertionSort和MergeSort两种排序算法的性能效率。

整体而言, MergeSort的性能最优, 对于近乎有序的数组的特殊情况, 近乎有序的数组, 数组越有序, InsertionSort的时间性能越趋近于O(n)。归并排序O(nlogn)。

相关文章