归并排序

归并排序

这次来讲一下归并排序的心得，首先归并排序的复杂度是o(nlogn)，相比于冒泡排序，选择排序来说，归并排序在处理大量数据进行排序的时候显得更为高效。
归并排序具体步骤如下：
首先以整个数组为对象执行mergesort（要传入数组的首元素位置，和数组末元素位置之后一个元素的位置）。
mergesort的具体操作如下
1.将给定的包含n个元素的局部数组分割为两个局部数组，每个元素包含n / 2个元素。
2.对两个局部数组分别执行mergesort排序
3.通过merge将两个已排序完毕的局部数组整合成一个数组。

在归并排序中，合并两个已排序数组的merge是整个算法的基础。我们要把包含n1个整数的数组L以及包含n2个整数的数组R合并到数组A中。假设L和R中的元素都已经按照升序排列，我们要做的是就是把L和R中的元素整合在一起，并且让所有的元素都按升序排列。

这里要注意的是，在合并的过程中我们不能使用其他排序算法（否则复杂度将会提升），这里我们要使用的是复杂度为o(n1 + n2)的合并算法进行合并。为了方便我们将在R数组和L数组的后面都放置一个很大的数（这里可以是int的最大值），这样在进行比较的时候就比较方便。

下面来一道具体的题目：

Write a program of a Merge Sort algorithm implemented by the following pseudocode. You should also report the number of comparisons in the Merge function.
Merge(A, left, mid, right)
n1 = mid - left;
n2 = right - mid;
create array L[0…n1], R[0…n2]
for i = 0 to n1-1
do L[i] = A[left + i]
for i = 0 to n2-1
do R[i] = A[mid + i]
L[n1] = SENTINEL
R[n2] = SENTINEL
i = 0;
j = 0;
for k = left to right-1
if L[i] <= R[j]
then A[k] = L[i]
i = i + 1
else A[k] = R[j]
j = j + 1

Merge-Sort(A, left, right){
if left+1 < right
then mid = (left + right)/2;
call Merge-Sort(A, left, mid)
call Merge-Sort(A, mid, right)
call Merge(A, left, mid, right)
Input
In the first line n is given. In the second line, n integers are given.
Output
In the first line, print the sequence S. Two consequtive elements should be separated by a space character.
In the second line, print the number of comparisons.
Constraints
n ≤ 500000
0 ≤ an element in S ≤ 109
Sample Input 1
10
8 5 9 2 6 3 7 1 10 4
Sample Output 1
1 2 3 4 5 6 7 8 9 10
34
Notes

代码如下：

#include<bits/stdc++.h>
using namespace std;
#define max 500000
#define sentinel 2000000000

int l[max / 2 + 2];
int r[max / 2 + 2];
int cnt;

void merge(int a[],int n,int left,int mid,int right)
{
	int n1 = mid - left;
	int n2 = right - mid;
	int i = 0;
	int j = 0;
	for(i = 0;i < n1;i++)
	{
		l[i] = a[left + i];
	}
	for(j = 0;j < n2;j++)
	{
		r[j] = a[mid + j];
	}
	l[n1] = sentinel;
	r[n2] = sentinel;
	i = 0;
	j = 0;
	for(int k = left;k < right;k++)
	{
		cnt++;
		if(l[i] <= r[j])
		{
			a[k] = l[i++];
		}	
		else
		{
			a[k] = r[j++];
		}
	} 
}

void mergesort(int a[],int n,int left,int right)
{
	if(left + 1 < right)
	{
		int mid = (left + right) / 2;
		mergesort(a,n,left,mid);
		mergesort(a,n,mid,right);
		merge(a,n,left,mid,right);
	}
}

int main()
{
	int a[max] = {0};
	int n = 0;
	int i = 0;
	cnt = 0;
	scanf("%d",&n);
	for(i = 0;i < n;i++)
	{
		scanf("%d",&a[i]);
	}
	
	mergesort(a,n,0,n);
	
	for(i = 0;i < n;i++)
	{
		if(i)
		{
			cout << " ";
		}
		cout << a[i];	
	} 
	cout << endl;
	cout << cnt << endl;
	return 0;	
} 

总结：
归并排序包含不相邻元素之间的比较，但不会直接交换。合并过程中如果出现2个元素相同的情况，那么L数组的元素优先R数组的元素。这样相同元素的顺序就不会颠倒，所以归并排序是一种稳定排序算法。
归并排序虽然高效，但是也是有一定代价的，代价就是用空间换取了时间复杂度。