常用内部排序算法之一：归并排序

时间：2022-12-23 00:11:00

前言
归并排序是所有常用内部排序算法中稳定性最好的，无论是平均时间复杂度、最坏时间复杂度还是最好时间复杂度，其时间复杂度都是O(nlogn)。由于这个特性，在需要考虑排序稳定性的情况下，归并排序是所有优化算法（直接插入排序、冒泡排序和简单选择排序）使用最多的。其实归并排序算法的思想很简单：假设初始序列含有n个记录，则可以看成是n个有序的子序列，每一个子序列的长度都是1，然后把这些子序列两两归并，得到 ⌈n/2⌉ （ ⌈x⌉ 表示不小于 x 的最小整数）个长度为2或者1的有序子序列；再两两归并，……，如此重复，直至得到一个长度为n的有序序列为止。这种方法也被称为2路归并排序。

首先看代码的实现过程：

package com.rhwayfun.algorithm.sort;

/**
 * 归并排序
 * @author Administrator
 *
 */
public class MergeSort2 {

public void mergeSort(int[] a){
        mSort(a,a,0,a.length - 1);
for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }
    }

private void mSort(int[] b, int[] a, int i, int j) {
int m = 0;
int[] c = new int[a.length];
if(i == j){//递归终止条件
            a[i] = b[i];
        }else {
            m = (i + j)/2;
//将数组a分为a[i...m]并进行排序
            mSort(b,c,i,m);
//数组a[m+1...j]部分进行排序
            mSort(b, c, m + 1, j);
//将a[i...m]部分和a[m+1...j]部分的排序结果归并到a
            merge(c,a,i,m,j);
        }
    }

private void merge(int[] b, int[] a, int i, int m, int t) {
int j = 0,k = 0,l = 0;
for(j = m+1,k = i;i <= m && j<=t;k++){
//将b中记录由小到大归并到a中
if(b[i] < b[j]){
                a[k] = b[i++];
            }else {
                a[k] = b[j++];
            }
        }
//将剩余b[i...m]复制到a中
if(i<=m){
for(l=0;l<=m-i;l++){
                a[k+l]=b[i+l];
            }
        }
//将剩余b[m+1...t]复制到数组a中
if(j<=t){
for(l=0;l<=t-j;l++){
                a[k+l]=b[j+l];
            }
        }
    }

public static void main(String[] args) {
new MergeSort2().mergeSort(new int[]{50,10,90,30,70,40,80,60,20});
    }
}

下面以序列{50,10,90,30,70,40,80,60,20}为例，说明归并排序的具体过程：

  1. 初始时刻，mSort方法中的数组b和数组a都是{50,10,90,30,70,40,80,60,20}
  2. i = 0，j = 9,显然两者不相等，将数组b分为b[i…m]和b[m+1…j]，此时m = 5，也就是数组b 正中间下标
  3. 然后递归调用mSort函数，继续将b[0…5]和b[6…9]拆成两组，直到每组只有一个元素
  4. 两次递归调用mSort函数之后，b[0…5]和b[6…9]已经排好序了，最后将这两组排好序的数组继续归并成最终排好序的数组，这个过程调用的是merge函数，该函数的主要目的就是将最好的两组进行归并排序
  5. 将排好序的数组返回给原数组a，排序结束

归并排序小结

由于归并排序在归并过程中需要与原始记录序列同样数量的存储空间存放归并结果以及递归时深度为 log2n 的栈空间，因此归并排序的空间复杂度是 O(n+logn) 。

归并排序的总的时间复杂度是 O(nlogn) ，同时这也是最好、最坏、平均的时间复杂度。需要注意的是，归并排序的是一种稳定的排序算法，但是归并排序是比较占用内存的。
标签：

相关文章