skywang12345

导航

统计
 

 

概要

本章介绍排序算法中的归并排序。内容包括:
1. 归并排序介绍
2. 归并排序图文说明
3. 归并排序的时间复杂度和稳定性
4. 归并排序实现
4.1  归并排序C实现
4.2  归并排序C++实现
4.3  归并排序Java实现

转载请注明出处:http://www.cnblogs.com/skywang12345/p/3602369.html


更多排序和算法请参考:数据结构与算法系列 目录

 

归并排序介绍

将两个的有序数列合并成一个有序数列,我们称之为"归并"。
归并排序(Merge Sort)就是利用归并思想对数列进行排序。根据具体的实现,归并排序包括"从上往下"和"从下往上"2种方式。


1. 从下往上的归并排序:将待排序的数列分成若干个长度为1的子数列,然后将这些数列两两合并;得到若干个长度为2的有序数列,再将这些数列两两合并;得到若干个长度为4的有序数列,再将它们两两合并;直接合并成一个数列为止。这样就得到了我们想要的排序结果。(参考下面的图片)

2. 从上往下的归并排序:它与"从下往上"在排序上是反方向的。它基本包括3步:
① 分解 -- 将当前区间一分为二,即求分裂点 mid = (low + high)/2;
② 求解 -- 递归地对两个子区间a[low...mid] 和 a[mid+1...high]进行归并排序。递归的终结条件是子区间长度为1。
③ 合并 -- 将已排序的两个子区间a[low...mid]和 a[mid+1...high]归并为一个有序的区间a[low...high]。

 

下面的图片很清晰的反映了"从下往上"和"从上往下"的归并排序的区别。

 

归并排序图文说明

归并排序(从上往下)代码

/*
 * 将一个数组中的两个相邻有序区间合并成一个
 *
 * 参数说明:
 *     a -- 包含两个有序区间的数组
 *     start -- 第1个有序区间的起始地址。
 *     mid   -- 第1个有序区间的结束地址。也是第2个有序区间的起始地址。
 *     end   -- 第2个有序区间的结束地址。
 */
void merge(int a[], int start, int mid, int end)
{
    int *tmp = (int *)malloc((end-start+1)*sizeof(int));    // tmp是汇总2个有序区的临时区域
    int i = start;            // 第1个有序区的索引
    int j = mid + 1;        // 第2个有序区的索引
    int k = 0;                // 临时区域的索引

    while(i <= mid && j <= end)
    {
        if (a[i] <= a[j])
            tmp[k++] = a[i++];
        else
            tmp[k++] = a[j++];
    }

    while(i <= mid)
        tmp[k++] = a[i++];

    while(j <= end)
        tmp[k++] = a[j++];

    // 将排序后的元素,全部都整合到数组a中。
    for (i = 0; i < k; i++)
        a[start + i] = tmp[i];

    free(tmp);
}

/*
 * 归并排序(从上往下)
 *
 * 参数说明:
 *     a -- 待排序的数组
 *     start -- 数组的起始地址
 *     endi -- 数组的结束地址
 */
void merge_sort_up2down(int a[], int start, int end)
{
    if(a==NULL || start >= end)
        return ;

    int mid = (end + start)/2;
    merge_sort_up2down(a, start, mid); // 递归排序a[start...mid]
    merge_sort_up2down(a, mid+1, end); // 递归排序a[mid+1...end]

    // a[start...mid] 和 a[mid...end]是两个有序空间,
    // 将它们排序成一个有序空间a[start...end]
    merge(a, start, mid, end);
}


从上往下的归并排序采用了递归的方式实现。它的原理非常简单,如下图:

通过"从上往下的归并排序"来对数组{80,30,60,40,20,10,50,70}进行排序时:
1. 将数组{80,30,60,40,20,10,50,70}看作由两个有序的子数组{80,30,60,40}和{20,10,50,70}组成。对两个有序子树组进行排序即可。
2. 将子数组{80,30,60,40}看作由两个有序的子数组{80,30}和{60,40}组成。
    将子数组{20,10,50,70}看作由两个有序的子数组{20,10}和{50,70}组成。
3. 将子数组{80,30}看作由两个有序的子数组{80}和{30}组成。
    将子数组{60,40}看作由两个有序的子数组{60}和{40}组成。
    将子数组{20,10}看作由两个有序的子数组{20}和{10}组成。
    将子数组{50,70}看作由两个有序的子数组{50}和{70}组成。

 

归并排序(从下往上)代码

/*
 * 对数组a做若干次合并:数组a的总长度为len,将它分为若干个长度为gap的子数组;
 *             将"每2个相邻的子数组" 进行合并排序。
 *
 * 参数说明:
 *     a -- 待排序的数组
 *     len -- 数组的长度
 *     gap -- 子数组的长度
 */
void merge_groups(int a[], int len, int gap)
{
    int i;
    int twolen = 2 * gap;    // 两个相邻的子数组的长度

    // 将"每2个相邻的子数组" 进行合并排序。
    for(i = 0; i+2*gap-1 < len; i+=(2*gap))
    {
        merge(a, i, i+gap-1, i+2*gap-1);
    }

    // 若 i+gap-1 < len-1,则剩余一个子数组没有配对。
    // 将该子数组合并到已排序的数组中。
    if ( i+gap-1 < len-1)
    {
        merge(a, i, i + gap - 1, len - 1);
    }
}

/*
 * 归并排序(从下往上)
 *
 * 参数说明:
 *     a -- 待排序的数组
 *     len -- 数组的长度
 */
void merge_sort_down2up(int a[], int len)
{
    int n;

    if (a==NULL || len<=0)
        return ;

    for(n = 1; n < len; n*=2)
        merge_groups(a, len, n);
}

从下往上的归并排序的思想正好与"从下往上的归并排序"相反。如下图:

通过"从下往上的归并排序"来对数组{80,30,60,40,20,10,50,70}进行排序时:
1. 将数组{80,30,60,40,20,10,50,70}看作由8个有序的子数组{80},{30},{60},{40},{20},{10},{50}和{70}组成。
2. 将这8个有序的子数列两两合并。得到4个有序的子树列{30,80},{40,60},{10,20}和{50,70}。
3. 将这4个有序的子数列两两合并。得到2个有序的子树列{30,40,60,80}和{10,20,50,70}。
4. 将这2个有序的子数列两两合并。得到1个有序的子树列{10,20,30,40,50,60,70,80}。

 

归并排序的时间复杂度和稳定性

归并排序时间复杂度
归并排序的时间复杂度是O(N*lgN)。
假设被排序的数列中有N个数。遍历一趟的时间复杂度是O(N),需要遍历多少次呢?
归并排序的形式就是一棵二叉树,它需要遍历的次数就是二叉树的深度,而根据完全二叉树的可以得出它的时间复杂度是O(N*lgN)。

归并排序稳定性
归并排序是稳定的算法,它满足稳定算法的定义。
算法稳定性 -- 假设在数列中存在a[i]=a[j],若在排序之前,a[i]在a[j]前面;并且排序之后,a[i]仍然在a[j]前面。则这个排序算法是稳定的!

 

归并排序实现

下面给出归并排序的三种实现:C、C++和Java。这三种实现的原理和输出结果都是一样的,每一种实现中都包括了"从上往下的归并排序"和"从下往上的归并排序"这2种形式。
归并排序C实现
实现代码(merge_sort.c)

  1 /**
  2  * 归并排序:C 语言
  3  *
  4  * @author skywang
  5  * @date 2014/03/12
  6  */
  7 
  8 #include <stdio.h>
  9 #include <stdlib.h>
 10 
 11 // 数组长度
 12 #define LENGTH(array) ( (sizeof(array)) / (sizeof(array[0])) )
 13 
 14 /*
 15  * 将一个数组中的两个相邻有序区间合并成一个
 16  *
 17  * 参数说明:
 18  *     a -- 包含两个有序区间的数组
 19  *     start -- 第1个有序区间的起始地址。
 20  *     mid   -- 第1个有序区间的结束地址。也是第2个有序区间的起始地址。
 21  *     end   -- 第2个有序区间的结束地址。
 22  */
 23 void merge(int a[], int start, int mid, int end)
 24 {
 25     int *tmp = (int *)malloc((end-start+1)*sizeof(int));    // tmp是汇总2个有序区的临时区域
 26     int i = start;            // 第1个有序区的索引
 27     int j = mid + 1;        // 第2个有序区的索引
 28     int k = 0;                // 临时区域的索引
 29 
 30     while(i <= mid && j <= end)
 31     {
 32         if (a[i] <= a[j])
 33             tmp[k++] = a[i++];
 34         else
 35             tmp[k++] = a[j++];
 36     }
 37 
 38     while(i <= mid)
 39         tmp[k++] = a[i++];
 40 
 41     while(j <= end)
 42         tmp[k++] = a[j++];
 43 
 44     // 将排序后的元素,全部都整合到数组a中。
 45     for (i = 0; i < k; i++)
 46         a[start + i] = tmp[i];
 47 
 48     free(tmp);
 49 }
 50 
 51 /*
 52  * 归并排序(从上往下)
 53  *
 54  * 参数说明:
 55  *     a -- 待排序的数组
 56  *     start -- 数组的起始地址
 57  *     endi -- 数组的结束地址
 58  */
 59 void merge_sort_up2down(int a[], int start, int end)
 60 {
 61     if(a==NULL || start >= end)
 62         return ;
 63 
 64     int mid = (end + start)/2;
 65     merge_sort_up2down(a, start, mid); // 递归排序a[start...mid]
 66     merge_sort_up2down(a, mid+1, end); // 递归排序a[mid+1...end]
 67 
 68     // a[start...mid] 和 a[mid...end]是两个有序空间,
 69     // 将它们排序成一个有序空间a[start...end]
 70     merge(a, start, mid, end);
 71 }
 72 
 73 
 74 /*
 75  * 对数组a做若干次合并:数组a的总长度为len,将它分为若干个长度为gap的子数组;
 76  *             将"每2个相邻的子数组" 进行合并排序。
 77  *
 78  * 参数说明:
 79  *     a -- 待排序的数组
 80  *     len -- 数组的长度
 81  *     gap -- 子数组的长度
 82  */
 83 void merge_groups(int a[], int len, int gap)
 84 {
 85     int i;
 86     int twolen = 2 * gap;    // 两个相邻的子数组的长度
 87 
 88     // 将"每2个相邻的子数组" 进行合并排序。
 89     for(i = 0; i+2*gap-1 < len; i+=(2*gap))
 90     {
 91         merge(a, i, i+gap-1, i+2*gap-1);
 92     }
 93 
 94     // 若 i+gap-1 < len-1,则剩余一个子数组没有配对。
 95     // 将该子数组合并到已排序的数组中。
 96     if ( i+gap-1 < len-1)
 97     {
 98         merge(a, i, i + gap - 1, len - 1);
 99     }
100 }
101 
102 /*
103  * 归并排序(从下往上)
104  *
105  * 参数说明:
106  *     a -- 待排序的数组
107  *     len -- 数组的长度
108  */
109 void merge_sort_down2up(int a[], int len)
110 {
111     int n;
112 
113     if (a==NULL || len<=0)
114         return ;
115 
116     for(n = 1; n < len; n*=2)
117         merge_groups(a, len, n);
118 }
119 
120 void main()
121 {
122     int i;
123     int a[] = {80,30,60,40,20,10,50,70};
124     int ilen = LENGTH(a);
125 
126     printf("before sort:");
127     for (i=0; i<ilen; i++)
128         printf("%d ", a[i]);
129     printf("\n");
130 
131     merge_sort_up2down(a, 0, ilen-1);        // 归并排序(从上往下)
132     //merge_sort_down2up(a, ilen);            // 归并排序(从下往上)
133 
134     printf("after  sort:");
135     for (i=0; i<ilen; i++)
136         printf("%d ", a[i]);
137     printf("\n");
138 }
View Code

归并排序C++实现
实现代码(MergeSort.cpp)

  1 /**
  2  * 归并排序:C++
  3  *
  4  * @author skywang
  5  * @date 2014/03/12
  6  */
  7 
  8 #include <iostream>
  9 using namespace std;
 10 
 11 /*
 12  * 将一个数组中的两个相邻有序区间合并成一个
 13  *
 14  * 参数说明:
 15  *     a -- 包含两个有序区间的数组
 16  *     start -- 第1个有序区间的起始地址。
 17  *     mid   -- 第1个有序区间的结束地址。也是第2个有序区间的起始地址。
 18  *     end   -- 第2个有序区间的结束地址。
 19  */
 20 void merge(int* a, int start, int mid, int end)
 21 {
 22     int *tmp = new int[end-start+1];    // tmp是汇总2个有序区的临时区域
 23     int i = start;            // 第1个有序区的索引
 24     int j = mid + 1;        // 第2个有序区的索引
 25     int k = 0;                // 临时区域的索引
 26 
 27     while(i <= mid && j <= end)
 28     {
 29         if (a[i] <= a[j])
 30             tmp[k++] = a[i++];
 31         else
 32             tmp[k++] = a[j++];
 33     }
 34 
 35     while(i <= mid)
 36         tmp[k++] = a[i++];
 37 
 38     while(j <= end)
 39         tmp[k++] = a[j++];
 40 
 41     // 将排序后的元素,全部都整合到数组a中。
 42     for (i = 0; i < k; i++)
 43         a[start + i] = tmp[i];
 44 
 45     delete[] tmp;
 46 }
 47 
 48 /*
 49  * 归并排序(从上往下)
 50  *
 51  * 参数说明:
 52  *     a -- 待排序的数组
 53  *     start -- 数组的起始地址
 54  *     endi -- 数组的结束地址
 55  */
 56 void mergeSortUp2Down(int* a, int start, int end)
 57 {
 58     if(a==NULL || start >= end)
 59         return ;
 60 
 61     int mid = (end + start)/2;
 62     mergeSortUp2Down(a, start, mid); // 递归排序a[start...mid]
 63     mergeSortUp2Down(a, mid+1, end); // 递归排序a[mid+1...end]
 64 
 65     // a[start...mid] 和 a[mid...end]是两个有序空间,
 66     // 将它们排序成一个有序空间a[start...end]
 67     merge(a, start, mid, end);
 68 }
 69 
 70 
 71 /*
 72  * 对数组a做若干次合并:数组a的总长度为len,将它分为若干个长度为gap的子数组;
 73  *             将"每2个相邻的子数组" 进行合并排序。
 74  *
 75  * 参数说明:
 76  *     a -- 待排序的数组
 77  *     len -- 数组的长度
 78  *     gap -- 子数组的长度
 79  */
 80 void mergeGroups(int* a, int len, int gap)
 81 {
 82     int i;
 83     int twolen = 2 * gap;    // 两个相邻的子数组的长度
 84 
 85     // 将"每2个相邻的子数组" 进行合并排序。
 86     for(i = 0; i+2*gap-1 < len; i+=(2*gap))
 87     {
 88         merge(a, i, i+gap-1, i+2*gap-1);
 89     }
 90 
 91     // 若 i+gap-1 < len-1,则剩余一个子数组没有配对。
 92     // 将该子数组合并到已排序的数组中。
 93     if ( i+gap-1 < len-1)
 94     {
 95         merge(a, i, i + gap - 1, len - 1);
 96     }
 97 }
 98 
 99 /*
100  * 归并排序(从下往上)
101  *
102  * 参数说明:
103  *     a -- 待排序的数组
104  *     len -- 数组的长度
105  */
106 void mergeSortDown2Up(int* a, int len)
107 {
108     int n;
109 
110     if (a==NULL || len<=0)
111         return ;
112 
113     for(n = 1; n < len; n*=2)
114         mergeGroups(a, len, n);
115 }
116 
117 int main()
118 {
119     int i;
120     int a[] = {80,30,60,40,20,10,50,70};
121     int ilen = (sizeof(a)) / (sizeof(a[0]));
122 
123     cout << "before sort:";
124     for (i=0; i<ilen; i++)
125         cout << a[i] << " ";
126     cout << endl;
127 
128     mergeSortUp2Down(a, 0, ilen-1);        // 归并排序(从上往下)
129     //mergeSortDown2Up(a, ilen);            // 归并排序(从下往上)
130 
131     cout << "after  sort:";
132     for (i=0; i<ilen; i++)
133         cout << a[i] << " ";
134     cout << endl;
135 
136     return 0;
137 }
View Code

归并排序Java实现
实现代码(MergeSort.java)

  1 /**
  2  * 归并排序:Java
  3  *
  4  * @author skywang
  5  * @date 2014/03/12
  6  */
  7 
  8 public class MergeSort {
  9 
 10     /*
 11      * 将一个数组中的两个相邻有序区间合并成一个
 12      *
 13      * 参数说明:
 14      *     a -- 包含两个有序区间的数组
 15      *     start -- 第1个有序区间的起始地址。
 16      *     mid   -- 第1个有序区间的结束地址。也是第2个有序区间的起始地址。
 17      *     end   -- 第2个有序区间的结束地址。
 18      */
 19     public static void merge(int[] a, int start, int mid, int end) {
 20         int[] tmp = new int[end-start+1];    // tmp是汇总2个有序区的临时区域
 21         int i = start;            // 第1个有序区的索引
 22         int j = mid + 1;        // 第2个有序区的索引
 23         int k = 0;                // 临时区域的索引
 24 
 25         while(i <= mid && j <= end) {
 26             if (a[i] <= a[j])
 27                 tmp[k++] = a[i++];
 28             else
 29                 tmp[k++] = a[j++];
 30         }
 31 
 32         while(i <= mid)
 33             tmp[k++] = a[i++];
 34 
 35         while(j <= end)
 36             tmp[k++] = a[j++];
 37 
 38         // 将排序后的元素,全部都整合到数组a中。
 39         for (i = 0; i < k; i++)
 40             a[start + i] = tmp[i];
 41 
 42         tmp=null;
 43     }
 44 
 45     /*
 46      * 归并排序(从上往下)
 47      *
 48      * 参数说明:
 49      *     a -- 待排序的数组
 50      *     start -- 数组的起始地址
 51      *     endi -- 数组的结束地址
 52      */
 53     public static void mergeSortUp2Down(int[] a, int start, int end) {
 54         if(a==null || start >= end)
 55             return ;
 56 
 57         int mid = (end + start)/2;
 58         mergeSortUp2Down(a, start, mid); // 递归排序a[start...mid]
 59         mergeSortUp2Down(a, mid+1, end); // 递归排序a[mid+1...end]
 60 
 61         // a[start...mid] 和 a[mid...end]是两个有序空间,
 62         // 将它们排序成一个有序空间a[start...end]
 63         merge(a, start, mid, end);
 64     }
 65 
 66 
 67     /*
 68      * 对数组a做若干次合并:数组a的总长度为len,将它分为若干个长度为gap的子数组;
 69      *             将"每2个相邻的子数组" 进行合并排序。
 70      *
 71      * 参数说明:
 72      *     a -- 待排序的数组
 73      *     len -- 数组的长度
 74      *     gap -- 子数组的长度
 75      */
 76     public static void mergeGroups(int[] a, int len, int gap) {
 77         int i;
 78         int twolen = 2 * gap;    // 两个相邻的子数组的长度
 79 
 80         // 将"每2个相邻的子数组" 进行合并排序。
 81         for(i = 0; i+2*gap-1 < len; i+=(2*gap))
 82             merge(a, i, i+gap-1, i+2*gap-1);
 83 
 84         // 若 i+gap-1 < len-1,则剩余一个子数组没有配对。
 85         // 将该子数组合并到已排序的数组中。
 86         if ( i+gap-1 < len-1)
 87             merge(a, i, i + gap - 1, len - 1);
 88     }
 89 
 90     /*
 91      * 归并排序(从下往上)
 92      *
 93      * 参数说明:
 94      *     a -- 待排序的数组
 95      */
 96     public static void mergeSortDown2Up(int[] a) {
 97         if (a==null)
 98             return ;
 99 
100         for(int n = 1; n < a.length; n*=2)
101             mergeGroups(a, a.length, n);
102     }
103 
104     public static void main(String[] args) {
105         int i;
106         int a[] = {80,30,60,40,20,10,50,70};
107 
108         System.out.printf("before sort:");
109         for (i=0; i<a.length; i++)
110             System.out.printf("%d ", a[i]);
111         System.out.printf("\n");
112 
113         mergeSortUp2Down(a, 0, a.length-1);        // 归并排序(从上往下)
114         //mergeSortDown2Up(a);                    // 归并排序(从下往上)
115 
116         System.out.printf("after  sort:");
117         for (i=0; i<a.length; i++)
118             System.out.printf("%d ", a[i]);
119         System.out.printf("\n");
120     }
121 }
View Code

 

上面3种实现的原理和输出结果都是一样的。下面是它们的输出结果:

before sort:80 30 60 40 20 10 50 70 
after  sort:10 20 30 40 50 60 70 80 

 

posted on 2014-04-28 09:44 如果天空不死 阅读(...) 评论(...) 编辑 收藏