高效的排序算法

#include <vector>
#include <algorithm>
#include <iostream>

static const int kEmergyMax = 500;
static const int kInsertMax = 10;
static const int kRandomNum = 2000;

template <typename Comparable>
void print(std::vector<Comparable> &a) {
	for (auto &i : a) {
		std::cout << i << " ";
	}
	std::cout << std::endl;
}


template <typename Comparable>
void _insertsort(std::vector<Comparable>& a,  int left, int right) {
	if (left >= right) return;
	Comparable tmp;
	int j = 0;
	for (int i = 0; i <= right; ++i) {
		tmp = std::move(a[i]);
		for (j = i; j > 0 && tmp < a[j - 1]; --j) {
			a[j] = std::move(a[j-1]);
		}
		a[j] = std::move(tmp);
	}
}


template <typename Comparable>
void _emergysort(std::vector<Comparable>& a, int left, int right) {
	if (right - left >= kInsertMax && right - left > 0) {
		std::vector<Comparable> tmp;
		int center = left + (right - left) / 2;
		
		_emergysort(a, left, center);
		_emergysort(a, center + 1, right);
		int l_index = left, r_index = center + 1;
		while (l_index <= center && r_index <= right) {
			if (a[l_index] <= a[r_index])
				tmp.push_back(std::move(a[l_index++]));
			else 
				tmp.push_back(std::move(a[r_index++]));
		}
		while (l_index <= center)
			tmp.push_back(std::move(a[l_index++]));
		while (r_index <= right)
			tmp.push_back(std::move(a[r_index++]));
		
		for (l_index = 0; l_index < tmp.size(); ++l_index) {
			a[l_index + left] = std::move(tmp[l_index]);
		}
	}else {
      _insertsort( a, left, right);
	}
	return;
	
}


template <typename Comparable>
const Comparable& _median3(std::vector<Comparable>& a, int left, int right) {
	int center = left + (right - left) / 2;
	if (a[left] > a[center])
		std::swap(a[left], a[center]);
	if (a[center] > a[right])
		std::swap(a[center], a[right]);
	if (a[left] > a[center])
		std::swap(a[left], a[center]);
	std::swap(a[center], a[right - 1]);
	return a[right - 1];
}

template <typename Comparable>
void _qsort(std::vector<Comparable>& a, int left, int right){
	if (right - left >= kEmergyMax) {
		const Comparable& pivot = _median3(a, left, right);
		int i = left, j = right - 1;
		for ( ; ; ) {
			while(a[++i] < pivot);
			while(a[--j] > pivot);
			if (i < j) 
				std::swap(a[i], a[j]);
			else
				break;
		}
		std::swap(a[i], a[right-1]);
		_qsort(a, left, i - 1);
		_qsort(a, i + 1, right);
	} else 
		_emergysort( a, left, right);
	return;
}



template <typename Comparable>
void qsort(std::vector<Comparable>& a) {
	_qsort(a, 0, a.size() -1);
}



int main(){
	std::vector<int> a;
	for (int i = 0; i < kRandomNum; ++i) {
		a.push_back(i / 2);
	}
    std::random_shuffle(a.begin(), a.end());

	std::cout << "before sort" << std::endl;
	print(a);
	
	qsort(a);

	std::cout << "after sort" << std::endl;
	print(a);
	return 0;
}

根据数据量的变化选择最合适的排序算法（>=1000用快排， >=10 用归并，否则用插入）