经典排序算法（五） —— Merge Sort 归并排序

简介
排序过程
实现
- 版本一
- 版本二
复杂度

简介

约翰·冯·诺伊曼在 1945 年提出了归并排序。归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。

将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。

归并排序的时间复杂度是O(nlogn）。代价是需要额外的内存空间。

排序过程

实现

版本一

@Test
public void test() {
    int[] nums = new int[]{4, 2, 8, 9, 6, 3, 5, 7, 1, 2};
    int[] mergeSort = mergeSortSimple(nums, 0, nums.length - 1);
    printArray(mergeSort);
}


/*
 * 归并排序
 * @param nums 待排序数组
 * @param start 开始位置
 * @param end   结束位置
 * @return
 */
public int[] mergeSortSimple(int[] nums, int start, int end) {
    if (start == end) {
        return new int[]{nums[start]};
    }
    int mid = (start + end) / 2;
    int[] m1 = mergeSortSimple(nums, start, mid);
    int[] m2 = mergeSortSimple(nums, mid + 1, end);
    return mergeNumsSimple(m1, m2);
}

/**
  * 合并两个有序数组
  * @param num1 待合并数组1
  * @param num2 待合并数组2
  * @return 合并数组
*/
public int[] mergeNumsSimple(int[] num1, int[] num2) {
    int l1 = num1.length;
    int l2 = num2.length;
    int[] resNum = new int[l1 + l2];
    int resIdx = 0;
    int index1 = 0;
    int index2 = 0;
    while (resIdx < resNum.length) {
        while (index1 < l1 && index2 < l2) {
            resNum[resIdx++] = num1[index1] < num2[index2] ? num1[index1++] : num2[index2++];
        }
        while (index1 < l1) {
            resNum[resIdx++] = num1[index1++];
        }
        while (index2 < l2) {
            resNum[resIdx++] = num2[index2++];
        }
    }
    return resNum;
}

	
/**
 * 打印数组
 * @param nums
*/
public void printArray(int[] nums) {
    for (int num : nums) {
        System.out.print(num + "\t");
    }
    System.out.println();
}

版本二


 
@Test
public void test() {
    int[] nums = new int[]{4, 2, 8, 9, 6, 3, 5, 7, 1, 2};
    int[] res = new int[nums.length];
    mergeSortSimpleOpt(nums, 0, nums.length - 1, res);
    printArray(res);
}


/**
 * 归并排序
*/
public void mergeSortSimpleOpt(int[] nums, int start, int end, int[] res) {
        if (start == end) {
            return;
        }
        int mid = (start + end) / 2;
        mergeSortSimpleOpt(nums, start, mid, res);
        mergeSortSimpleOpt(nums, mid + 1, end, res);
        mergeOpt(nums, start, end, res);
}

/**
* 版本一递归过程中会有额外的临时数组开销，在此版本优化，直接传入定义好的结果数组做合并
*/
public void mergeOpt(int[] nums, int start, int end, int[] res) {
    int end1 = (start + end) / 2;
    int start2 = end1 + 1;

    int idx1 = start;
    int idx2 = start2;
    int resIdx = idx1 + idx2 - start2;
    while (idx1 <= end1 && idx2 <= end) {
        res[resIdx++] = nums[idx1] < nums[idx2] ? nums[idx1++] : nums[idx2++];
    }
    while (idx1 <= end1) {
        res[resIdx++] = nums[idx1++];
    }
    while (idx2 <= end) {
        res[resIdx++] = nums[idx2++];
    }
    while (start <= end) {
        nums[start] = res[start++];
    }
}

复杂度

O（nlogn）