归并排序的优化
一、对归并算法的优化：
假设有a和b两个有序序列：
a1，a2，a3，……，an 和 b1，b2，b3，……，bm
1、若an <= b1，直接返回。
代价：一次比较时间。
分析：an <= b1 在归并前期发生的概率不会很大，但是到后期时，归并序列基本有序，an <= b1 发生的概率会大很多，
所以这种优化个人认为值得采用。
2、尽可能缩短a序列和b序列。比如a序列为1，3，5，7，9，11，b序列为4，6，9，13，17，21，40，则a序列中1，3和b序列中的
13，17，21，40可不参与归并。
3、归并前先将a序列拷贝到临时数组中，归并时直接在原数组中进行。
代价：假设2中a序列缩短i，b序列缩短j，则一次归并的代价为2*(n-i)+(m-j)次复制。无改优化的算法代价为
2*（n-i+m-j)。（比较次数相同，不予讨论）
分析：这本是C++STL应对归并算法内存不足时所采用的策略，采用这种策略不仅能提高效率还能降低内存占用。
二、对排序策略的优化：
当归并序列小于某个阈值（C++STL阈值设为20）时，采用插入排序进行排序。
三、对实现方式的优化：
插入排序和归并排序都采用非递归算法，因为非递归算法总是比递归算法效率高，但不是一定，比如快速排序。
C++代码（STL风格）如下：
/*
*macro.h
*定义命名空间qmk
*/
#ifndef MACRO_H
#define MACRO_H
#define BEGIN_NAMESPACE_QMK namespace qmk \
{
#define END_NAMESPACE_QMK }
#endif
/* *constant.h *定义插入排序阈值 */ #ifndef CONSTANT_H #define CONSTANT_H #include<cstdint> #include"macro.h" BEGIN_NAMESPACE_QMK uint32_t INSERTIONSORT_THRESHOLD = 20; //cstdint为C++11头文件，非C++11编译器则使用stdint.h，该文件包含uint32_t的定义 END_NAMESPACE_QMK #endif
/*
*algorithm_base.h
*实现归并算法
*/
#ifndef ALGORITHM_BASE_H
#define ALGORITHM_BASE_H
#include<cstdint>
#include"constant.h"
#include"macro.h"
BEGIN_NAMESPACE_QMK
template<typename T>
void merge_forward(T *begin,T *middle,T *end)
{
if(begin == middle || middle == end || *(middle-1) <= *middle)
{
return; //优化一（1）
}
while(*begin <= *middle)
{
++begin; //优化一（2）
}
uint32_t buf_len = middle-begin;
T *buffer = new T[buf_len];
for(T *ptr = buffer,*ptr_src = begin ; ptr_src != middle ; ++ptr,++ptr_src)
{
*ptr = *ptr_src; //优化一（3）
}
T *beg_one = buffer,*beg_two = middle,*first_end = buffer+buf_len;
while(beg_one != first_end && beg_two != end)
{
*begin++ = (*beg_one <= *beg_two ? *beg_one++ : *beg_two++);
//优化一（3）。在原数组中进行归并。
}
for( ; beg_one != first_end ; ++begin,++beg_one)
{
*begin = *beg_one;
//优化一（2）。如果序列a先结束，则b序列剩余的元素已位于正确位置，可不参与归并
}
delete[] buffer;
}
END_NAMESPACE_QMK
#endif
/*
*insertion_sort.h
*插入排序的实现(非递归)
*/
#ifndef INSERTION_SORT_H
#define INSERTION_SORT_H
#include"macro.h"
BEGIN_NAMESPACE_QMK
template<typename T>
void insertion_sort_iteration(T *begin,T *end)
{
for(T* ptr_key = begin+1 ; ptr_key < end ; ++ptr_key)
{
T const key = *ptr_key;
T *ptr_scan = ptr_key;
if(*ptr_scan < *begin)
{
for( ; ptr_scan != begin ; --ptr_scan)
{
*ptr_scan = *(ptr_scan-1);
}
}
else //拆分两种情况，减少比较次数（参考C++STL）
{
for( ; *(ptr_scan-1) > key ; --ptr_scan)
{
*ptr_scan = *(ptr_scan-1);
}
}
*ptr_scan = key;
}
}
END_NAMESPACE_QMK
#endif
/*
*merge_sort.h
*归并排序的实现(非递归)
*/
#ifndef MERGE_SORT_H
#define MERGE_SORT_H
#include<cstdint>
#include"algorithm_base.h"
#include"constant.h"
#include"macro.h"
#include"insertion_sort.h"
BEGIN_NAMESPACE_QMK
template<typename T>
void merge_sort_iteration(T* begin,T* end)
{
for(T *ptr_begin = begin,*ptr_end = NULL ; ptr_begin < end ; ptr_begin = ptr_end)
{
ptr_end = ptr_begin + INSERTIONSORT_THRESHOLD;
insertion_sort_iteration(ptr_begin,ptr_end > end ? end : ptr_end);
//归并序列小于阈值时才用插入排序进行排序
}
for(uint32_t length = INSERTIONSORT_THRESHOLD,lst_length = end - begin ;
length < lst_length ; length <<= 1)
{
uint32_t d_length = length << 1;
for(T *ptr_begin = begin,*ptr_end = NULL,*loop_end = end - length ;
ptr_begin < loop_end ; ptr_begin += d_length)
{
ptr_end = ptr_begin + d_length;
merge_forward(ptr_begin,ptr_begin+length,ptr_end > end ? end : ptr_end);
}
}
}
END_NAMESPACE_QMK
#endif
上述优化是本人综合C++STL，java SE和自己的一些见解得出来的四不像归并排序，欢迎拍砖。
测试代码如下：
#include<iostream>
#include<algorithm>
#include<iterator>
#include<string>
#include<sstream>
#include<cstdlib>
#include<cstdint>
#include"../merge_sort.h"
int main(int32_t argc,char **argv)
{
using namespace std;
using namespace qmk;
if(argc<2)
{
cerr<<"No enough parameter."<<endl;
exit(1);
}
int32_t length = argc-1;
int32_t *array = new int32_t[length];
int32_t *array_copy = new int32_t[length];
stringstream *ss = static_cast<stringstream*>(operator new(sizeof(stringstream)));
for(int32_t idx = 1 ; idx < argc ; ++idx)
{
new(ss) stringstream(string(argv[idx]));
*ss>>array[idx-1];
ss->~stringstream();
}
operator delete(ss);
merge_sort_iteration(array,array+length);
copy(array,array+length,ostream_iterator<int32_t>(cout," "));
cout<<endl;
return 0;
}
linux测试脚本如下：
用法：
./Generate.sh <程序名> <程序测试次数> <归并序列长度> <排序结果输出文件>
#!/bin/bash if [ $# -lt 4 ] then echo No enough parameter. echo "Generate.sh <program> <data count> <args count> <output file>" exit 1 fi counter=$2 for ((count=0; count<counter; ++count)) do argsCounter=$[$RANDOM%$3+1] args='' for ((argsCount=0; argsCount<argsCounter ; ++argsCount)) do args=$args+$RANDOM+' ' done ./$1 $args >>$4 echo >>$4 done exit 0用法：
./Judge.sh <比较方式，-lt（小于）或-gt（大于）> <排序结果输入文件>
#!/bin/bash
if [ $# -lt 2 ]
then
echo No enough parameter.
echo "Judge.sh <compare method> <input file>"
exit 1
fi
declare -a LINE
cat $2 | while read -a LINE
do
length=$[${#LINE[@]}-1]
for ((count=0 ; count<length ; ++count))
do
if [ ${LINE[$[$count+1]]} $1 ${LINE[$count]} ]
then
echo ${LINE[@]}
break
fi
done
done
exit 0
若排序结果有误，则会输出错误的排序结果，否则没有输出。