七大排序算法之改进算法系列（六）——归并排序

归并排序（Merging Sort）:

归并排序是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。实际上就是将数据序列划分为越来越小的半子表，再对半子表排序，最后再用递归方法将排好序的半子表合并成越来越大的有序序列。

图解如下：

 

归并排序的递归实现代码：

#include <iostream>
#define MAXSIZE 10

using namespace std;

// 实现归并，并把最后的结果存放到list1里
void merging(int *list1, int list1_size, int *list2, int list2_size)
{
	int i, j, k, m;
	int temp[MAXSIZE];

	i = j = k = 0;

	while (i < list1_size && j < list2_size)
	{
		if (list1[i] < list2[j])
		{
			temp[k++] = list1[i++];
		}
		else
		{
			temp[k++] = list2[j++];
		}
	}

	while (i < list1_size)
	{
		temp[k++] = list1[i++];
	}

	while (j < list2_size)
	{
		temp[k++] = list2[j++];
	}

	for (m = 0; m < (list1_size + list2_size); m++)
	{
		list1[m] = temp[m];
	}
}

void MergeSort(int k[], int n)
{
	if (n > 1)
	{
		int *list1 = k;
		int list1_size = n / 2;
		int *list2 = k + n / 2;
		int list2_size = n - list1_size;

		MergeSort(list1, list1_size);
		MergeSort(list2, list2_size);

		merging(list1, list1_size, list2, list2_size);
	}
}

int main()
{
	int i, a[10] = { 5, 2, 6, 0, 3, 9, 1, 7, 4, 8 };

	cout << "排序前的数组是：";
	for (i = 0; i < 10; i++)
	{
		cout << a[i];
	}
	cout << endl;

	MergeSort(a, 10);

	cout << "排序后的数组是：";
	for (i = 0; i < 10; i++)
	{
		cout << a[i];
	}
	cout << endl;

	return 0;
}

代码结果：

---

 归并排序的非递归方法：

递归方法是先拆分成一个个小的子表再递归回一个完整的表的过程。

而迭代方法不需要这样，直截了当，把表两个两个排序再四个四个再八个八个......

看代码：

#include <iostream>
#include <malloc.h>
#define MAXSIZE 10

using namespace std;

void MergeSort(int k[],int n)
{
	int i,next,left_min,left_max,right_min,right_max;
	//开辟一个与原来数组一样大小的空间用来存储用
	int *temp = (int *)malloc(n * sizeof(int));
	//逐级上升，第一次比较2个，第二次比较4个，第三次比较8个。。。
	for(i=1; i<n; i*=2)
	{
		//每次都从0开始，数组的头元素开始
		for(left_min=0; left_min<n-i; left_min = right_max)
		{
			right_min = left_max = left_min + i;
			right_max = left_max + i;
			//右边的下标最大值只能为n
			if(right_max>n)
			{
				right_max = n;
			}
			//next是用来标志temp数组下标的，由于每次数据都有返回到K，
			//故每次开始得重新置零
			next = 0;
			//如果左边的数据还没达到分割线且右边的数组没到达分割线，开始循环
			while(left_min<left_max&&right_min<right_max)
			{
				if(k[left_min] < k[right_min])
				{
					temp[next++] = k[left_min++];
					
				}
				else
				{
					temp[next++] = k[right_min++];
				}
			}
			//上面循环结束的条件有两个，如果是左边的游标尚未到达，那么需要把
			//数组接回去，可能会有疑问，那如果右边的没到达呢，其实模拟一下就可以
			//知道，如果右边没到达，那么说明右边的数据比较大，这时也就不用移动位置了
			
			while(left_min < left_max)
			{
				//如果left_min小于left_max，说明现在左边的数据比较大
				//直接把它们接到数组的min之前就行
				k[--right_min] = k[--left_max];	
			}
			while(next>0)
			{
				//把排好序的那部分数组返回该k
				k[--right_min] = temp[--next];		
			}
		}
	}
}

int main()
{
	int i, a[10] = { 5, 2, 6, 0, 3, 9, 1, 7, 4, 8 };

	cout << "排序前的数组是：";
	for (i = 0; i < 10; i++)
	{
		cout << a[i];
	}
	cout << endl;

	MergeSort(a, 10);

	cout << "排序后的数组是：";
	for (i = 0; i < 10; i++)
	{
		cout << a[i];
	}
	cout << endl;

	return 0;
}

 结果：

归并排序的时间复杂度和空间复杂度分析：

递归版本：

时间复杂度：O(nlogn)

空间复杂度：O(n+logn)

迭代版本：

时间复杂度：O(nlogn)

空间复杂度：O(n)