归并排序
这次来讲一下归并排序的心得,首先归并排序的复杂度是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数组的元素。这样相同元素的顺序就不会颠倒,所以归并排序是一种稳定排序算法。
归并排序虽然高效,但是也是有一定代价的,代价就是用空间换取了时间复杂度。