数据结构-二路归并及归并排序

一、介绍：

二、二路归并介绍

void Merge(int* a1, int a1size, int* a2, int a2size, int* res)
{
//合并两个有序序列a1 a2 结果保存在res数组中
int a1_index, a2_index, res_index;
a1_index = a2_index = res_index = 0;
while (a1_index < a1size && a2_index < a2size)
{
if (a1[a1_index] < a2[a2_index])
res[res_index++] = a1[a1_index++];
else
res[res_index++] = a2[a2_index++];
}

//将a1或a2剩余部分插入到res
while (a1_index < a1size)
res[res_index++] = a1[a1_index++];
while (a2_index < a2size)
res[res_index++] = a2[a2_index++];
}

int main()
{
int a1[] = { 2,3,5 };
int a2[] = { 2,9 };
int a1size = sizeof(a1) / sizeof(a1[0]);
int a2size = sizeof(a2) / sizeof(a2[0]);
int a3size = a1size + a2size;
int* a3 = new int[a3size];

Merge(a1, a1size, a2, a2size, a3);

for (int i = 0; i < a3size; i++)
cout << a3[i] << " " << endl;

system("pause");
return 0;
}

三、归并排序主体思想：

四、代码实现及测试：

#include <iostream>

using namespace std;

//将子序列归并为一个完整序列
void Merge(int* a, int first, int mid, int last, int* res)
{
//将a[first mid] a[mid+1 last]排序合并
int first_start = first, first_end = mid;
int second_start = mid + 1, second_end = last;
int res_index = 0;
while (first_start <= mid && second_start <= last)
{
if (a[first_start] < a[second_start])
res[res_index++] = a[first_start++];
else
res[res_index++] = a[second_start++];
}

while (first_start <= mid)
res[res_index++] = a[first_start++];

while (second_start <= last)
res[res_index++] = a[second_start++];

//拷贝回原来的空间
for (int i = 0; i < res_index; i++)
a[first + i] = res[i];
}

//递归不断划分区间
void merge_sort(int* a, int first, int last, int* res)
{
if (first >= last)
return;

int mid = (first + last) / 2;
merge_sort(a, first, mid, res);     //左边有序
merge_sort(a, mid + 1, last, res);  //右边有序
Merge(a, first, mid, last, res);    //将左右两个有序数列进行排序归并
}

bool MergeSort(int a[], int n)
{
int *res = new int
;
if (res == NULL)
return false;
merge_sort(a, 0, n - 1, res);
for (int i = 0; i < n; i++)
cout << a[i] << " ";

delete[] res;
return true;
}

int main()
{
int a[] = {3,2,5,9,2};
MergeSort(a, sizeof(a) / sizeof(a[0]));

system("pause");
return 0;
}


输入结果为：2    2   3   5   9

五：图示整个归并排序过程：


六、优化思路
由于使用递归的方式将数组划分到不能再划分为止，再依次进行排序后归并，栈帧开销非常大，可以采用小区间优化的方式，在划分的过程中判断子序列的元素个数，若小于10（可根据情况而定），可利用插入排序来直接完成此段空间的排序过程。这样一来就可以减少递归次数，尤其是当数据量变大时就会很明显（插入排序讲解参考插入排序讲解）

七、非递归实现
非递归实现中，就不需要先划分为一个再归并，而是直接可以归并两个元素，然后四个，八个…，假如数组为6,2,8,1,5,4，非递归过程图示如下：



代码实现：

void Merge(int* a, int first, int mid, int last, int* res)
{
//将a[first mid] a[mid+1 last]排序合并
int first_start = first, first_end = mid;
int second_start = mid + 1, second_end = last;
int res_index = 0;
while (first_start <= mid && second_start <= last)
{
if (a[first_start] < a[second_start])
res[res_index++] = a[first_start++];
else
res[res_index++] = a[second_start++];
}

while (first_start <= mid)
res[res_index++] = a[first_start++];

while (second_start <= last)
res[res_index++] = a[second_start++];

//拷贝回原来的空间
for (int i = 0; i < res_index; i++)
a[first + i] = res[i];
}

//len为数组元素个数
void MergeSortNR(int* a,int len)
{
int size = 1; //size为一半部分的元素个数
int left, right, mid;
left = right = mid = 0;
int* tmp = new int[len];

while (size <= len - 1)
{
left = 0;
while (left + size <= len -1)
{
//mid等于left+子序列一半的个数-1;
mid = left + size - 1;
right = mid + size;

//若right超出数组范围，right=最后一个元素下标
if (right > len - 1)
right = len - 1;

Merge(a, left, mid, right, tmp);
left = right + 1;
}
size *= 2;
}
}