C++泛型编程练习三 选择排序，归并排序，冒泡排序，快速排序

	 /*
		简单选择排序
	 */
	template<typename T,typename Compare=Less<T>>
	static std::vector<T>& simple_select_sort(std::vector<T>& arg) {
		if (arg.empty())return arg;
		Compare comp;
		for (int64_t i = 0; i < arg.size(); i++)
		{
			int64_t base_pos = i;
			for (int64_t j = i+1; j < arg.size(); j++)
			{
				if (comp(arg[j], arg[base_pos]))base_pos=j;
			}
			T tmp=arg[i];
			arg[i] = arg[base_pos];
			arg[base_pos]=tmp;
		}
		return arg;
	}
	/*
		归并排序
	*/
	template<typename T, typename Compare = Less<T>>
	static std::vector<T>& merge_sort(std::vector<T>& arg,int64_t begin,int64_t len) {
		if (len <2)return arg;
		int64_t left_len = len / 2;
		int64_t right_len = len - left_len;
		merge_sort<T, Compare>(arg, begin, left_len);
		merge_sort<T, Compare>(arg, begin+ left_len, right_len);
		//merge
		std::vector<T> tmp;
		tmp.resize(len);
		Compare comp;
		int64_t merge_pos_1 = 0, merge_pos_2 = 0,write_pos=0;
		while (merge_pos_1 < left_len && merge_pos_2 < right_len)
		{
			if (comp(arg[begin+merge_pos_1], arg[begin+left_len+merge_pos_2]))
			{
				tmp[write_pos++] = arg[begin + (merge_pos_1++)];
			}
			else
			{
				tmp[write_pos++] = arg[begin + left_len+(merge_pos_2++)];
			}
		}
		while(merge_pos_1<left_len)tmp[write_pos++]= arg[begin + (merge_pos_1++)];
		while (merge_pos_2 < right_len)tmp[write_pos++] = arg[begin + left_len + (merge_pos_2++)];
		write_pos = 0;
		std::for_each(tmp.begin(), tmp.end(), [&](T& val) {
			arg[begin + (write_pos++)] = val;
			});
		return arg;
	}
	/*
		冒泡排序
	*/
	template<typename T, typename Compare = Less<T>>
	static std::vector<T>& bubble_sort(std::vector<T>& arg) {
		if (arg.empty())return arg;
		Compare comp;
		int64_t last_swap_pos = arg.size();
		for (int64_t i = 0; i < arg.size()&& last_swap_pos>1; i++)
		{
			int64_t swap_pos = last_swap_pos;
			for (int64_t j = 1; j < swap_pos; j++)
			{
				if (comp(arg[j], arg[j - 1]))
				{
					std::swap(arg[j], arg[j - 1]);
					last_swap_pos = j;
				}
			}
		}
		return arg;
	}
	/*
		快速排序
	*/
	template <typename T>
	struct default_quick_sort {
		std::pair<T,int64_t> operator()(std::vector<T>& arg,int64_t begin,int64_t len) {
			if (len < 3)return std::make_pair<T, int64_t>(0,0);
			int64_t medium = (len ) / 2;
			if (arg[begin+medium] > arg[begin])
			{
				if (arg[begin + medium] < arg[begin+len - 1])return std::pair<T, int64_t>(arg[begin+medium], begin+medium);
				if (arg[begin + medium] > arg[begin+len - 1])return std::pair<T, int64_t>(arg[begin], begin);
				return std::pair<T, int64_t>(arg[begin+len-1], begin+len-1);
			}
			else {
				if (arg[begin + medium] > arg[begin+len - 1])return std::pair<T, int64_t>(arg[begin + medium], begin + medium);
				if (arg[begin]< arg[begin+len - 1])return std::pair<T, int64_t>(arg[begin], begin);
				return std::pair<T, int64_t>(arg[begin+len - 1], begin+len - 1);
			}
		}
	};
	template<typename T, typename Compare = Less<T>,typename Pick= default_quick_sort<T>>
	static std::vector<T>& quick_sort(std::vector<T>& arg,int64_t begin,int64_t len) {
		if (len <2)return  arg;
		Compare comp;
		if (len == 2)
		{
			if (comp(arg[begin + 1], arg[begin]))std::swap(arg[begin + 1], arg[begin]);
			return  arg;
		}
		Pick pick;
		auto key_data = pick(arg, begin, len);
		//将keydata存至排序队列的最后位置
		std::swap(arg[key_data.second],arg[begin + len - 1]);
		key_data.second = begin + len - 1;
		int64_t left_pos = 0 + begin, right_pos = key_data.second - 1;
		while (1)
		{
			while (left_pos < right_pos && comp(arg[left_pos], key_data.first))left_pos++;
			while (left_pos < right_pos && !comp(arg[right_pos], key_data.first))right_pos--;
			//交换
			std::swap(arg[left_pos], arg[right_pos]);
			left_pos++;
			if (left_pos >= right_pos)break;
		}
		//插入keydata
		if (!comp(arg[right_pos], key_data.first))std::swap(arg[right_pos], arg[key_data.second]);
		else {
			std::swap(arg[right_pos + 1], arg[key_data.second]);
			right_pos++;
		}
		quick_sort<T, Compare, Pick>(arg, begin, right_pos  - begin);
		quick_sort<T, Compare, Pick>(arg, right_pos+1, len+begin-right_pos-1);
		return arg;
	}