归并排序算法（排序详解）

 归并排序

基本思想

归并排序的核心是将两个有序序列合并为一个有序序列。因此将两个有序序列合并成一个有序序列是归并排序的基础算法。归并排序主要分为递归归并排序与迭代归并排序：

递归归并排序即将无序的序列S[s:t]分成两个部分：S[s:m]和S[m+1:t]，m=(s+t)/2。

迭代归并排序即将初始长度为n的数组看成n个长度为1的有序子表，然后将相邻的有序子表两两合并，得到[n/2]个长度为2或1的有序子表（如果n为奇数，则最后一个有序子表的长度为1），再两两归并得到[n/4]个有序子表，以此类推，直至得到长为n的有序序列。

操作方法

 合并方法：

设a[l:h]是一个线性表（序列），将a[l:h]分为两个子序列a[l:m],a[m+1:h],其中，a[l:m]和a[m+1:h]分别有序。那么我们设置两个指针：x指针指向a[l]，y指针指向a[m+1]。

当他们都不指向末尾时，将*x与*y进行比较，将较小的数放到b[]数组（保存数组）里，同时，将较小的那个子序列指针右移。

当x指向末尾时，把y指向的元素及其之后的元素全部放进b[]即可。

当y指向末尾时，把x指向的元素及其之后的元素全部放进b[]即可。

递归归并：

递归归并排序即将无序的序列S[s:t]分成两个部分：S[s:m]和S[m+1:t]，m=(s+t)/2。

 

迭代归并：

迭代归并排序即将初始长度为n的数组看成n个长度为1的有序子表，然后将相邻的有序子表两两合并，得到[n/2]个长度为2或1的有序子表（如果n为奇数，则最后一个有序子表的长度为1），再两两归并得到[n/4]个有序子表，以此类推，直至得到长为n的有序序列。

 

          

 算法实现

private static void Merge(int a[], int b[], int l, int m, int h) {
				int i, j, k;
				i = l; // i 指的是第一个子序列a[1:m]
				j = m + 1; // j 指的是第二个子序列a[m+1:h]
				k = l; // k 指的是最后用来存放合并后的数组的数组
				while (i <= m && j <= h) {
					if (a[i] < a[j]) {
						b[k] = a[i];
						i++;
						k++;
					} else {
						b[k] = a[j];
						j++;
						k++;
					}
				}
				while (i <= m) {
					b[k++] = a[i++];
				}
				while (j <= h) {
					b[k++] = a[j++];
				}
			}

			// 迭代归并算法
			private static void mergePass(int S[], int T[], int n, int len) {
				int i = 0;
				while (i + 2 * len < n) {
					Merge(S, T, i, i + len - 1, i + 2 * len - 1);
					i += 2 * len;
				}
				if (i + len <= n) // 一个归并段长len，另一个对并段长度不足len
				{
					Merge(S, T, i, i + len - 1, n - 1);
				}
			}

			// 迭代实现的归并排序算法
			public static void mergeSort(int R[], int T[], int n) {
				int temp[] = R.clone();
				int len = 1;
				while (len < n) {
					mergePass(temp, T, n, len);
					temp = T.clone(); // 不加这句的话，temp的数组一直没有发生变化
					len *= 2;
				}
	}

 

 效率分析

算法性能：

时间复杂度：

归并排序的形式就是一棵二叉树，它需要遍历的次数就是二叉树的深度，而根据完全二叉树的可以得出它的时间复杂度是O(n*log2n)。

空间复杂度

由前面的算法说明可知，算法处理过程中，需要一个大小为n的临时存储空间用以保存合并序列。

算法稳定性

在归并排序中，相等的元素的顺序不会改变，所以它是稳定的。