归并排序

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

归并过程分解

假设两个有序表分别为a,b，最后归并到r表中。

归并过程：比较a[i]和a[j]的大小，若a[i]≤a[j]，则将第一个有序表中的元素a[i]复制到r[k]中，并令i和k分别加上1；否则将第二个有序表中的元素a[j]复制到r[k]中，并令j和k分别加上1，如此循环下去，直到其中一个有序表取完，然后再将另一个有序表中剩余的元素复制到r中从下标k到下标t的单元。归并排序的算法我们通常用递归实现，先把待排序区间[s,t]以中点二分，接着把左边子区间排序，再把右边子区间排序，最后把左区间和右区间用一次归并操作合并成有序的区间[s,t]。

示例分解

假设原始序列为：{6，202，100，301，38，8，1}，其长度len = 7，归并过程：

1、第一次归并：先中分得到mid索引为3，递归归并左半部分{6， 202， 100， 301}，对这个子序列又中分为{6, 202}和{100, 301}，此时这两个子序列已有序；递归归并右半部分{38, 8, 1}，对这个子序列又中分为{38, 8}和{1}，归并后形成{8，38}和{1}，共比较3次

2、第二次归并：第一次归并后变成{6,202},{100,301},{8,38},{1}，即{6， 202，100，301，8，38，1}，再中分得到{6，202，100，301}和{8，38，1}，分别递归归并后为{6，100，202，301}新序列和{1，8，31}新序列，共比较3+1=4次。

3、第三次归并：第二次归并后，得到的两个有序的子序列为{6，100，202，301}和{1，8，38}，这一次是递归回到第一层了，已经是中分了，直接比较和复制到新的r即可。最终得到{1，6，8，38，100，202，301}，共比较4次（6与1比较，6与8比较，100与8比较，100与38比较）。

这个序列从无序到有序总共比较了3+4+4=11次。

算法复杂度分析

归并排序的效率是比较高的，假设数列长度为N，采用中分法的方式将数列分开成若干个小数列一共要log2^N 步，每步都是一个合并有序数列的过程，时间复杂度可以记为O ( N )，故一共为O ( N * log2^N)。

因为归并排序每次都是在相邻的数据中进行操作，所以归并排序在常用的几种排序方法（快速排序，归并排序，希尔排序，堆排序）中也是效率比较高的。

时间复杂度：O ( N * log2^N )

C语言实现

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85

/** *  归并排序算法 * *  @param list   待排序的序列 *  @param first    子序列的起点索引 *  @param last   子序列的终点索引 *  @param temp   临时数组，用于将两个子序列二路归并时存储 */ void mergeSort(int list[], int first, int last, int temp[]) {   if (first < last) {     int mid = (first + last) / 2;          // 递归归并中分左子序列，使子序列有序     mergeSort(list, first, mid, temp);          // 递归归并中分右子序列，使子序列有序     mergeSort(list, mid + 1, last, temp);          // 最后二路归并，使序列成有序     // 必须明白的一点，每次中分递归归并都需要二路归并，因为中分后的任意子序列     // 在有序后，都要二路归并成一个序列     mergeList(list, first, mid, last, temp);   } }   /** *  二路归并list[first...mid]子序列与list[mid+1...last] * *  @param list 序列 *  @param first    左子序列的起点 *  @param mid      序列中间分割点 *  @param last 右序列终点 *  @param temp 临时序列，用于将两个无序的子序列归并到temp中，使之有序 */ void mergeList(int list[], int first, int mid, int last, int temp[]) {   int leftIndex = first;   int leftEndIndex = mid;      int rightIndex = mid + 1;   int rightEndIndex = last;      int tempIndex = 0;      // 寻找两个子序列，顺序遍历，将值小的复制到临时数组中，直到其中一个子序列遍历完毕   while (leftIndex <= leftEndIndex && rightIndex <= rightEndIndex) {     // 值小的就复制到临时数组中     if (list[leftIndex] <= list[rightIndex]) {       temp[tempIndex] = list[leftIndex];       tempIndex++;       leftIndex++;     } else {       temp[tempIndex] = list[rightIndex];       tempIndex++;       rightIndex++;     }   }      // 有可能左子序列更长，因此将剩下的部分直接复制到临时数组中   while (leftIndex <= leftEndIndex) {     temp[tempIndex++] = list[leftIndex++];   }      // 有可能右子序列更长，因此将剩下的部分直接复制到临时数组中   while (rightIndex <= rightEndIndex) {     temp[tempIndex++] = list[rightIndex++];   }      // 最后还需要将有序的临时数组复制到原始序列中   for (int i = 0; i < tempIndex; ++i) {     list[first + i] = temp[i];   }   // 这里添加一个打印，记录归并 NSMutableString *str = [[NSMutableString alloc] init];   for (int i = 0; i < sizeof(list) - 1; ++i) {     if (i == 0) {       [str appendFormat:@"%d", list[i]];     } else {       [str appendFormat:@", %d", list[i]];     }   }   NSLog(@"此次二路归并后，得到的序列为：(%@)", str); }

测试：

 

1 2 3 4 5

int list[] = {6, 202, 100, 301, 38, 8, 1}; int temp[7] = {0}; mergeSort(list, 0, 7-1, temp);

打印效果：

 

1 2 3 4 5 6 7 8

此次二路归并后，得到的序列为：(6, 202, 100, 301, 38, 8, 1) 此次二路归并后，得到的序列为：(6, 202, 100, 301, 38, 8, 1) 此次二路归并后，得到的序列为：(6, 100, 202, 301, 38, 8, 1) 此次二路归并后，得到的序列为：(6, 100, 202, 301, 8, 38, 1) 此次二路归并后，得到的序列为：(6, 100, 202, 301, 1, 8, 38) 此次二路归并后，得到的序列为：(1, 6, 8, 38, 100, 202, 301)

从打印结果可以看出来，果然与我们前面的算法分析是一样的。