1.简介
1.1 算法思想
归并排序是分治法(Divide and Conquer)的一个典型的应用,属于比较类非线性时间排序。比较类排序中性能最佳,应用广泛。
归并排序先使每个子列有序,再将子列合并成有序列。若将两个子序列合并成一个有序列,称为二路归并。
1.2 排序过程
设有数列 {16,23,100,3,38,128,23}
初始状态:16,23,100,3,38,128,23
第一次归并后:{16,23},{3,100},{38,128},{23};
第二次归并后:{3,16,23,100},{23,38,128};
第三次归并后:{3,16,23,23,38,100,128}。
完成排序。
1.3 复杂度分析
时间复杂度:最好、最坏和平均时间复杂度都是 O(nlogn),排序性能不受待排序数据的混乱程度影响,比较稳定,这也是相对于快排的优势所在。
空间复杂度为:O(n)。合并子序列时需要用到辅助空间,长度为数列长度 n。
稳定性:稳定,从上文排序过程中可以看出,黑体 23 一直在前面。
2.二路归并实现
2.1 C++ 串行实现
/************************************************
*函数名称:mergearray
*参数:a:待归并数组;first:开始下标;mid:中间下标;
* last:结束下标;temp:临时数组
*说明:将有二个有序数列a[first...mid]和a[mid...last]合并
*************************************************/
void mergearray(int a[], int first, int mid, int last, int temp[]) {
int i = first, j = mid + 1,k =0;
while (i <= mid && j <= last) {
if (a[i] <= a[j])
temp[k++] = a[i++];
else
temp[k++] = a[j++];
}
while (i<= mid)
temp[k++] = a[i++];
while (j <= last)
temp[k++] = a[j++];
for (i=0; i < k; i++)
a[first+i] = temp[i];
}
/************************************************
*函数名称:mergesort
*参数:a:待归并数组;first:开始下标;
* last:结束下标;temp:临时数组
*说明:实现给定数组区间的二路归并排序
*************************************************/
void mergesort(int a[], int first, int last, int temp[]) {
if (first < last) {
int mid = (first + last) / 2;
mergesort(a, first, mid, temp); //左边有序
mergesort(a, mid + 1, last, temp); //右边有序
mergearray(a, first, mid, last, temp); //再将二个有序数列合并
}
}
本机测试 100 * 1024 * 1024 = 100M 个 32bits 整型,串行需要 15.536s,以下是本机软硬件参数,为 Linux 平台。
2.2 C++ 并行实现
2.2.1 并行思路
将待排序数组通过偏移量进行逻辑切分为多块,将每个块传递给多个线程调用二路归并排序函数进行排序。待各个块内有序后,再合并各个块整合成有序数列。
2.2.2 并行代码
线程函数,供创建出来的线程调用。
/*******************************************
*函数名称:merge_exec
*参数: para指针,用于接收线程下边,表示第几个线程
*说明: 调用二路归并排序
*******************************************/
void* merge_exec(void *para) {
int threadIndex = *(int*)para;
int blockLen = DataNum/threadNum;
int* temp = new int[blockLen];
int offset = threadIndex*blockLen;
mergesort(randInt, offset, offset+blockLen-1, temp);
}
合并多个已经排好序的块。代码如下:
/***********************************************
*函数名称:mergeBlocks
*参数: pDataArray:块内有序的数组 arrayLen:数组长度
* blockNum:块数 resultArray:存放排序的结果
*说明: 合并有序的块
************************************************/
inline void mergeBlocks(int* const pDataArray,int arrayLen,const int blockNum,int* const resultArray) {
int blockLen=arrayLen/blockNum;
int blockIndex[blockNum];//各个块中元素在数组中的下标,VC可能不支持变量作为数组的长度,解决办法可使用宏定义
// 初始化块内元素起始下标。
for(int i=0;i<blockNum;++i) {
blockIndex[i]=i*blockLen;
}
int smallest=0;
// 扫描所有块内的所有元素。
for(int i=0;i<arrayLen;++i) {
// 以第一个未扫描完的块内元素作为最小数。
for(int j=0; j<blockNum; ++j) {
if(blockIndex[j]<(j*blockLen+blockLen)) {
smallest=pDataArray[blockIndex[j]];
break;
}
}
// 扫描各个块,寻找最小数。
for(int j=0;j<blockNum;++j) {
if((blockIndex[j]<(j*blockLen+blockLen))&&(pDataArray[blockIndex[j]]<smallest)) {
smallest=pDataArray[blockIndex[j]];
}
}
// 确定哪个块内元素下标进行自增。
for(int j=0;j<blockNum;++j) {
if((blockIndex[j]<(j*blockLen+blockLen))&&(pDataArray[blockIndex[j]]==smallest)) {
++blockIndex[j];
break;
}
}
// 本次循环最小数放入结果数组。
resultArray[i]=smallest;
}
}
main 函数中创建多线程完成并行排序,代码如下:
int main(int argc,char* argv[]) {
int threadBum=8;
int blockNum=threadNum;
struct timeval ts,te;
srand(time(NULL));
for(int i=0;i<DataNum;++i) {
randInt[i]=rand();
}
pthread_t tid[blockNum],ret[blockNum],threadIndex[blockNum];
//--------Two-way Merge Sort-------
gettimeofday(&ts,NULL);
for(int i = 0; i < threadNum; ++i) {
threadIndex[i]=i;
ret[i] = pthread_create(&tid[i], NULL,merge_exec,(void *)(threadIndex+i));
if(ret[i] != 0){
cout<<"thread "<<i<<" create error!"<<endl;
break;
}
}
for(int i = 0; i <threadNum; ++i) {
pthread_join(tid[i], NULL);
}
mergeBlocks(randInt, DataNum, threadNum, resultInt);
gettimeofday(&te, NULL);
cout<<"MergeSort time: "<<(te.tv_sec-ts.tv_sec)*1000+(te.tv_usec-ts.tv_usec)/1000<<"ms"<<endl;
}
8 线程情况下,测试性能为 4.223s,加速比 3.68。针对机器的缓存大小,通过提高缓存命中率,可继续进行算法优化,提高排序性能。