排序算法（六）、归并排序

1、二路归并排序
“归并”即“合并”，是指将两个或者两个以上有序表组合成一个有序表。假如待排序表含有 n 个记录，即可以视为 n 个有序的子表。每个子表长度为1，然后两两归并，得到 n/2 个长度为 2 或者 1 的有序表，然后，再两两归并，。。。。如此重复，直到合并成一个长度为 n 的有序表为止。这种排序方法称为“二路归并排序”。
递归形式的二路归并算法，主要包含两个步骤：
（1）、分解：将长度为 n 的待排序表分解成两个 n/2 大小的子表，然后，递归地对两个子表进行排序。。
（2）、合并：将子表合并。
（1）部分代码如下：void MergeSort(int a[], int low, int high)
{
if (low < high)
{
int mid = (low + high) / 2;
MergeSort(a,low,mid);
MergeSort(a,mid+1,high);
Merge(a,low,mid,high);

}
}（2）部分代码如下：// MergeSort 归并排序

void Merge(int a[], int low, int mid, int high)
{
int i = low, j = mid + 1, k = 0; // j 是从 mid + 1 开始的。
int *b = new(nothrow) int[high - low + 1];
if (!b)
{
cout << "分配失败" << endl;
return;
}

while (i <= mid && j <= high) // 分两路进行比较，把数据较小的放到中介数组
{
if (a[i] <= a[j])
b[k++] = a[i++];
else
b[k++] = a[j++];
}

while (i <= mid) // 若某个区间的数据仍然有剩余，就直接把剩余的数据复制到中介数组
b[k++] = a[i++];// 这两个循环只会执行其中一个。。因为肯定不会两边都有剩余
while (j <= high)
b[k++] = a[j++];

for (int i = low,k=0; i <= high; i++,k++) // 将 b 数组的元素复制到原数组
a[i] = b[k];

delete[]b;

}
测试：int main()
{
int a[] = { 1, 5, 3, 4, 12, 35, 21, 9 };
mergesort(a,0,7);

for (int i = 0; i < 8; i++)
cout << a[i] << endl;
return 0;
}对于非递归的形式，只需要更改 merge() 即可。void MergeSort(int arr[], int n)//n代表数组中元素个数，数组最大下标是n-1
{
int size = 1, low, mid, high;
while (size <= n - 1) // 使用步长来控制
{
low = 0;
while (low + size <= n - 1)
{
mid = low + size - 1;
high = mid + size;
if (high>n - 1)//第二个序列个数不足size
high = n - 1;
Merge(arr, low, mid, high);//调用归并子函数
//cout << "low:" << low << " mid:" << mid << " high:" << high << endl;//打印出每次归并的区间
low = high + 1;//下一次归并是第一关序列的下界
}
size *= 2;//范围扩大一倍
}
}举例说明一下：
// 非递归版本的 MergeSort
// 使用一个例子来解释这个排序，假设有 8 个数据，[48],[38],[65],[97],[76],[13],[27],[33]，元素个数 n = 8
// 初始时，size = 1,此时,size <= 7，
// 第一次内循环时，即 low + size <= n - 1，因为每次 low 都会递增，所以要保证不越界
// 一开始，low = 0,mid = 0,high = 1,这可以看成是元素的下标。调用归并函数，将 [48],[38]变成 [38,48].
// low = high +1 = 2,mid = 2,high = 3,调用归并函数，将 [69],[57]变成 [57,69].
//low = high +1 = 4,mid = 4,high = 5,调用归并函数，将 [76],[13]变成 [13,76].
//low = high +1 = 6,mid = 6,high = 7,调用归并函数，将 [27],[33]变成 [27,33].,这样，序列变成了 [38,48]，[57,69]，[13,76]，[27,33]

// 第二次，size = 2,size <=7
//一开始，low = 0,mid = 1,high = 3,[38,48]，[57,69]变成了 [38,48,57,69]
//然后，low = 3+1 = 4, mid = 5, high = 7, [13,76]，[27,33]变成了[13,27,33,76]

// 第三次，size = 4,size <=7
//一开始，low = 0,mid = 3,high = 7,这样 [38,48,57,69]，[13,27,33,76] 就变成了 [13,27,33,38,48,57,69,76]

性能分析：
空间复杂度：上面的 merge () 函数需要申请辅助单元， n 个单元。但是，每一趟归并以后，这些空间就被释放了，所以时间复杂度为 O(n)
时间复杂度: 每一趟归并的复杂度为 O(n)，总共进行 log2 (n) 趟归并。所以时间复杂度为 O(nlog2 (n))。

升级——原地归并排序
既然 merge() 函数需要辅助单元，那么，不使用额外的存储空间可以吗？