归并排序code

排序code

迭代

//基于迭代的归并排序
public static void mergeSortBU(int[] arr, int len){
    for (int sz = 1; sz <= len; sz += sz) {
        //对arr[i...i+sz-1]和arr[i+sz...i+2*sz-1]进行归并
        for (int i = 0; i+sz < len; i += 2*sz) {
            int low = i;
            int mid = i + sz - 1;
            int high = Math.min(i + sz + sz - 1, len - 1);
            merge(arr,low,mid, high);
        }
    }
}

递归

//基于递归的归并排序
public static void mergeSort(int[] nums, int low ,int high) {
    int mid = low + (high - low) / 2;
    if (mid < high) {
        //左边
        mergeSort(nums, low, mid);
        //右边
        mergeSort(nums, mid + 1, high);
        //左右合并
        merge(nums, low, mid, high);
    }
}

归并合并

   static void merge(int[] arr, int low , int mid, int high){
        int mergeLen = high-low+1;
        int[] temp = new int[mergeLen];
        int left = low;
        int right = mid+1;
        int i = 0;
        //把较小的数据放到新数组
        while (left<=mid && right<=high){
            if (arr[left]<arr[right]){
                temp[i++] = arr[left++];
            }else {
                temp[i++] = arr[right++];
            }
        }
        //把左数组中剩余的元素复制到排序数组
        while (left<=mid){
            temp[i++] = arr[left++];
        }
        //把右数组中剩余的元素复制到排序数组
        while (right<=high){
            temp[i++] = arr[right++];
        }
        //用新数组覆盖原数组
        for (int j = 0; j < mergeLen; j++) {
            arr[j + low] = temp[j];
        }
    }

测试

public static void main(String[] args){
    int[] array = MyUtil.createArray();
    int[] arrays = new int[array.length];
    System.arraycopy(array,0,arrays,0,array.length);
    //系统排序
    Arrays.sort(arrays);
    //堆排序
    MergeSort.mergeSortBU(array, array.length);
    boolean compare = MyUtil.compare(array,arrays);
    System.out.println(compare);
}