归并排序

归并排序: 效率高,会占用内存空间,在排序阶段会生成与排序数组相同大小的数组(内存充足随便用)

大O表示:Nlog2(N) 与 简单排序(O(N^2))相比,数据越大，效率相差越大

30万时间:57 ms

简单排序见 https://blog.youkuaiyun.com/fighterGuy/article/details/81707108

/归并排序  即二分排序和递归的结合体

public class MergeSort {
    private long[] theArray;

    private int nElems;

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

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

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

    public void mergeSort() {
        long[] workSpace = new long[nElems];
        remergeSort(workSpace, 0, nElems - 1);
    }

    // 递归workspace ,使最终的workspace中存放的数据为最小,即2个,再对这两个排序后放入theArray
    // 分析:  7 2 1 6
    // 初始:lower 0 uper 3 mid = (0 + 3)/2 = 1 先执行低轮次
    // 低轮次.轮次一: lower 0 uper 1 mid = (0 + 1)/2 = 0 
    // 低轮次.轮次二: lower 0 uper 0 返回执行结束
    // 低轮次.轮次一.高轮次一: (mid + 1) = 1  uper 1 返回执行结束
    // 低轮次.轮次一:执行merge lower 0 high 1 uper 1 现在执行的是数组最低位置的两个数进行排序(排序完成,低轮次执行完成)
    // 高轮次.伦次一: lower 2(mid + 1) uper 3 mid = (2 + 3)/2 = 2
    // 高轮次.伦次一.低轮次一: lower 2 mid 2 返回执行结束
    // 高轮次.轮次二: lower 3(mid + 1) uper 3; 返回执行轮次一
    // 高轮次.伦次一: 执行merge lower 2 high 3 uper 3 执行高轮次最高位两个数字的排序
    // 高轮次和低轮次都执行完成 现在的数据为 2 7 1 6 比较时通过索引把数据分成两节,进行比较
    // 执行merge lower 0 high 2 uper 3 
    private void remergeSort(long[] workSpace, int lower, int uper) {
        if (lower == uper) {
            return;
        } else {
            int mid = (lower + uper) / 2;
            remergeSort(workSpace, lower, mid);//执行低轮次
            remergeSort(workSpace, mid + 1, uper);//执行高轮次
            merge(workSpace, lower, mid + 1, uper);
        }
    }
    private void merge(long[] workSpace, int lower, int high, int uper) {
        int j = 0;
        int lowerBound = lower;
        int mid = high - 1;
        //每次进入只会是一段的比较,数组为连续的索引,个数为uper - lower
        int n = uper - lowerBound + 1;

        // 以下循环 和进行两个有序数组的归并是一样的 ,判断如果小于直接放进workspace,然后判断是否放完
        while (lower <= mid && high <= uper) {
            if (theArray[lower] < theArray[high]) {
                workSpace[j++] = theArray[lower++];
            } else {
                workSpace[j++] = theArray[high++];
            }
        }
        while (lower <= mid) {
            workSpace[j++] = theArray[lower++];
        }

        while (high <= uper) {
            workSpace[j++] = theArray[high++];
        }

        // 将排序后的值放入theArray
        for (j = 0; j < n; j++) {
            theArray[lowerBound + j] = workSpace[j];
        }
    }