死磕归并排序算法

开发 前端 算法
要将一个数组排序,可以先将数组分为两个数组分别排序,然后再将结果归并在一起,重复递归这个过程,直到数组整体有序,这就是归并排序的算法思路。

本文转载自微信公众号「贝塔学JAVA」,作者Silently9527 。转载本文请联系贝塔学JAVA公众号。

前言

本篇我们谈一种基于归并操作完成排序的算法。

归并排序算法思路

要将一个数组排序,可以先将数组分为两个数组分别排序,然后再将结果归并在一起,重复递归这个过程,直到数组整体有序,这就是归并排序的算法思路。

归并排序的优点是它能够保证任意长度为N的数组排序所需的时间与 NlogN 成正比,这个优点是初级排序无法达到的。

缺点是因为归并操作需要引入额外的数组,额外的空间与N成正比

原地归并实现

在实现归并排序之前,我们需要先完成两个有序数组的归并操作,即将两个有序的数组合并成一个有序的数组;

  • 在此过程中我们需要引入一个辅助数组;
  • 定义的方法签名为merge(a, lo, mid, hi),这个方法将数组a[lo..mid]与a[mid..hi]归并成一个有序的数组,结果存放到a[lo..mid]中;
  • 该方法中需要使用的上一篇中的公共函数 less ,参考上一篇文章《常见的初级排序算法,这次全搞懂》
  1. public class MergeSort implements SortTemplate { 
  2.     private Comparable[] aux; 
  3.  
  4.     @Override 
  5.     public void sort(Comparable[] array) { 
  6.         //待实现 
  7.     } 
  8.  
  9.     private void merge(Comparable[] a, int lo, int mid, int hi) { 
  10.         for (int i = lo; i <= hi; i++) { 
  11.             aux[i] = a[i]; 
  12.         } 
  13.         int i = lo, j = mid + 1; 
  14.         for (int k = lo; k <= hi; k++) { 
  15.             if (i > mid) { 
  16.                 a[k] = aux[j++]; 
  17.             } else if (j > hi) { 
  18.                 a[k] = aux[i++]; 
  19.             } else if (less(aux[i], aux[j])) { 
  20.                 a[k] = aux[i++]; 
  21.             } else { 
  22.                 a[k] = aux[j++]; 
  23.             } 
  24.         } 
  25.     } 
  26.  

自顶向下的归并排序

基于分而治之的思想,大的数组排序,先递归拆分成小的数组,保证小的数组有序再归并,直到整个数组有序,这个操作就是自顶向下的归并排序

  1. public class MergeSort implements SortTemplate { 
  2.     private Comparable[] aux; 
  3.  
  4.     @Override 
  5.     public void sort(Comparable[] array) { 
  6.         aux = new Comparable[array.length]; 
  7.         doSort(array, 0, array.length - 1); 
  8.     } 
  9.  
  10.     private void doSort(Comparable[] array, int lo, int hi) { 
  11.         if (lo >= hi) { 
  12.             return
  13.         } 
  14.         int mid = (hi - lo) / 2 + lo; 
  15.         doSort(array, lo, mid); 
  16.         doSort(array, mid + 1, hi); 
  17.         merge(array, lo, mid, hi); 
  18.     } 
  19.  
  20.     private void merge(Comparable[] a, int lo, int mid, int hi) { 
  21.         //省略 
  22.     } 
  23.  

以上代码是标准的递归归并排序操作,但是经过仔细思考之后,该算法还有可以优化的地方

「测试数组是否已经有序」;如果a[mid]<=a[mid+1],那么我们就可以跳过merge方法,减少merge操作;修复之后的doSort方法

  1. private void doSort(Comparable[] array, int lo, int hi) { 
  2.     if (lo >= hi) { 
  3.         return
  4.     } 
  5.     int mid = (hi - lo) / 2 + lo; 
  6.     doSort(array, lo, mid); 
  7.     doSort(array, mid + 1, hi); 
  8.     if (array[mid].compareTo(array[mid + 1]) >= 0) { 
  9.         merge(array, lo, mid, hi); 
  10.     } 

「对于小规模的数组可以是用插入排序」;对于小规模的数组使用归并排序会增加递归调用栈,所以我们可以考虑使用插入排序来处理子数组的排序

  1. private void doSort(Comparable[] array, int lo, int hi) { 
  2.     if (lo >= hi) { 
  3.         return
  4.     } 
  5.  
  6.     if (hi - lo < 5) { //测试,小于5就使用插入排序 
  7.         insertionSort(array, lo, hi); 
  8.         return
  9.     } 
  10.  
  11.     int mid = (hi - lo) / 2 + lo; 
  12.     doSort(array, lo, mid); 
  13.     doSort(array, mid + 1, hi); 
  14.     if (less(array[mid + 1], array[mid])) { 
  15.         merge(array, lo, mid, hi); 
  16.     } 
  17.  
  18. //插入排序 
  19. private void insertionSort(Comparable[] array, int lo, int hi) { 
  20.     for (int i = lo; i <= hi; i++) { 
  21.         for (int j = i; j > lo && less(array[j], array[j - 1]); j--) { 
  22.             exch(array, j, j - 1); 
  23.         } 
  24.     } 

「节省复制元素到辅助数组的时间」;要实现该操作较麻烦,需要在每一层递归的时候交换输入数据和输出数组的角色;修改之后的完整代码如下:

  1. public class MergeSort implements SortTemplate { 
  2.     private Comparable[] aux; 
  3.  
  4.     @Override 
  5.     public void sort(Comparable[] array) { 
  6.         aux = array.clone(); 
  7.         doSort(aux, array, 0, array.length - 1); 
  8.     } 
  9.  
  10.     private void doSort(Comparable[] src, Comparable[] dest, int lo, int hi) { 
  11.         if (lo >= hi) { 
  12.             return
  13.         } 
  14.  
  15.         if (hi - lo < 5) { //测试,小于5就使用插入排序 
  16.             insertionSort(dest, lo, hi); 
  17.             return
  18.         } 
  19.  
  20.         int mid = (hi - lo) / 2 + lo; 
  21.         doSort(dest, src, lo, mid); 
  22.         doSort(dest, src, mid + 1, hi); 
  23.         if (less(src[mid + 1], src[mid])) { 
  24.             merge(src, dest, lo, mid, hi); 
  25.         } 
  26.     } 
  27.  
  28.     //插入排序 
  29.     private void insertionSort(Comparable[] array, int lo, int hi) { 
  30.         for (int i = lo; i <= hi; i++) { 
  31.             for (int j = i; j > lo && less(array[j], array[j - 1]); j--) { 
  32.                 exch(array, j, j - 1); 
  33.             } 
  34.         } 
  35.     } 
  36.  
  37.     private void merge(Comparable[] src, Comparable[] dest, int lo, int mid, int hi) { 
  38.         int i = lo, j = mid + 1; 
  39.         for (int k = lo; k <= hi; k++) { 
  40.             if (i > mid) { 
  41.                 dest[k] = src[j++]; 
  42.             } else if (j > hi) { 
  43.                 dest[k] = src[i++]; 
  44.             } else if (less(src[i], src[j])) { 
  45.                 dest[k] = src[i++]; 
  46.             } else { 
  47.                 dest[k] = src[j++]; 
  48.             } 
  49.         } 
  50.     } 
  51.  

每一层递归操作都会让子数组有序,但是子数组可能是aux[lo..hi]也有可能是a[lo..hi];由于第一次调用doSort传入的是src=aux,dest=array,所以递归最后的结果一定是输入到了array中,保证了array整体排序完成

自底向上的归并排序

实现归并算法还有另一种思路,就是先归并哪些小的数组,然后再成对归并得到子数组,直到整个数组有序

  1. public class MergeSort implements SortTemplate { 
  2.     private Comparable[] aux; 
  3.  
  4.     @Override 
  5.     public void sort(Comparable[] array) { 
  6.         int length = array.length; 
  7.         aux = new Comparable[length]; 
  8.         for (int sz = 1; sz < length; sz += sz) { 
  9.             for (int i = 0; i < length - sz; i += 2 * sz) { 
  10.                 merge(array, i, i + sz - 1, Math.min(i + 2 * sz - 1, length - 1)); 
  11.             } 
  12.         } 
  13.     } 
  14.  
  15.     private void merge(Comparable[] a, int lo, int mid, int hi) { 
  16.         for (int i = lo; i <= hi; i++) { 
  17.             aux[i] = a[i]; 
  18.         } 
  19.         int i = lo, j = mid + 1; 
  20.         for (int k = lo; k <= hi; k++) { 
  21.             if (i > mid) { 
  22.                 a[k] = aux[j++]; 
  23.             } else if (j > hi) { 
  24.                 a[k] = aux[i++]; 
  25.             } else if (less(aux[i], aux[j])) { 
  26.                 a[k] = aux[i++]; 
  27.             } else { 
  28.                 a[k] = aux[j++]; 
  29.             } 
  30.         } 
  31.     } 
  32.  

 

责任编辑:武晓燕 来源: 贝塔学JAVA
相关推荐

2011-04-20 14:29:07

归并排序

2023-10-09 07:11:03

排序算法序列

2022-04-06 08:58:39

归并排序Go算法

2021-04-16 09:40:52

Java数据结构算法

2021-01-26 05:33:07

排序算法快速

2023-10-09 00:12:55

归并排序数据

2022-09-21 08:38:40

归并排序C++Python

2021-02-04 13:10:32

归并排序算法

2021-10-12 07:15:02

归并排序场景

2020-08-18 08:22:46

归并排序

2021-06-03 08:32:18

JVM调优虚拟机

2023-03-08 08:03:09

数据结构算法归并排序

2012-12-27 11:11:54

华为任正非

2021-06-28 17:26:15

归并排序建模

2021-08-04 08:56:34

语言Go排序

2021-02-25 07:21:00

JVMJavaava虚拟机

2023-12-14 07:36:16

Java并发原子类

2023-04-27 09:13:20

排序算法数据结构

2013-06-05 09:38:27

Intel功耗酷睿

2021-06-01 09:29:43

ArthasJVM内存
点赞
收藏

51CTO技术栈公众号