【算法导论】归并排序实现

#ifndef MERGE_SORT_H
#define MERGE_SORT_H

#include <iterator>
#include <vector>
#include <cmath>
#include "INSERTION-SORT.h"

//
// 合并排序：
//	 最佳情况： n*lgn
//	 最坏情况： n*lgn
//	 一般情况： n*lgn
// 这是优化后的算法，在n非常小时，我们使用insertion-sort代替本来的过程进行排序
//
template <typename Iterator>
void optimizing_merge_sort(Iterator first, Iterator last)
{
	_opt_sort(first, last, std::_Val_type(first), std::_Dist_type(first), std::log2(last - frst));
}

template <typename Iterator, typename Val, typename Dis>
void _opt_sort(Iterator first, Iterator last, Val* value_type, Dis* distance_type, const size_t OPT_SIZE)
{
	// 如果size只有1，那么就直接返回
	if (last - first < OPT_SIZE)
	{
		insertion_sort(first, last);
		return;
	}

	// 计算三个指针p q r 分别是多少
	// 注意一下，这里的half_size只是(last - first)/2而已
	// 不需要加1的！！，因为last已经是最后一个元素的下一个元素了
	Dis half_size = (last - first) / 2;
	Iterator p = first;
	Iterator q = half_size + first;
	Iterator r = last;

	// 递归为解决这两个段的sort问题
	_opt_sort(p, q, value_type, distance_type);
	_opt_sort(q, r, value_type, distance_type);

	// merge这两段
	_merge(p, q, r, value_type);
}

//
// 合并排序：
//	 最佳情况： n*lgn
//	 最坏情况： n*lgn
//	 一般情况： n*lgn
// 这个算法在n非常小的时候，会出现insertion-sort比较快的情况
// 所以在n非常小时，可以转为insertion-sort，优化这个算法
//
template <typename Iterator>
void merge_sort(Iterator first, Iterator last)
{
	/************************************************************************/
	/* 
		算法原理：
			如果last - first == 1,那么表示这段数据只有一个
			那么就表示是已排好序的

			将first到last分为两段，指针分别为p, q和q, r
			迭代sort(p, q); sort(q, r);
			最后对已排好序的两段调用merge();
			子程序
	*/
	/************************************************************************/
	_sort(first, last, std::_Val_type(first), std::_Dist_type(first));
}

template <typename Iterator, typename Val, typename Dis>
void _sort(Iterator first, Iterator last, Val* value_type, Dis* distance_type)
{
	// 如果size只有1，那么就直接返回
	if (last == first + 1)
		return;

	// 计算三个指针p q r 分别是多少
	// 注意一下，这里的half_size只是(last - first)/2而已
	// 不需要加1的！！，因为last已经是最后一个元素的下一个元素了
	Dis half_size = (last - first) / 2;
	Iterator p = first;
	Iterator q = half_size + first;
	Iterator r = last;

	// 递归为解决这两个段的sort问题
	_sort(p, q, value_type, distance_type);
	_sort(q, r, value_type, distance_type);

	// merge这两段
	_merge(p, q, r, value_type);
}

template <typename Iterator, typename Val>
void _merge(const Iterator p, const Iterator q, const Iterator r, Val*)
{
	// 创建A[first1 - last1], B[first2 - last2]
	// 这个栈内存是必须有的，因为MERGE-SORT不是原地排序
	const size_t A_SZ = q - p;
	const size_t B_SZ = r - q;
	std::vector<Val> A(A_SZ);
	std::vector<Val> B(B_SZ);

	// 初始化A, B
	std::vector<Val>::iterator ptrA = A.begin();
	for (Iterator i = p; i != q; ++i, ++ptrA)
	{
		*ptrA = *i;
	}
	
	std::vector<Val>::iterator ptrB = B.begin();
	for (Iterator i = q; i != r; ++i, ++ptrB)
	{
		*ptrB = *i;
	}

	// 根据AB中的值，分配到iterator中
	ptrA = A.begin();
	ptrB = B.begin();
	for (Iterator cur = p; cur != r; ++cur)
	{
		if (ptrA == A.begin() + A_SZ)
		{
			*cur = *ptrB++;
			continue;
		}

		if (ptrB == B.begin() + B_SZ)
		{
			*cur = *ptrA++;
			continue;
		}

		if (*ptrA < *ptrB)
			*cur = *ptrA++;
		else
			*cur = *ptrB++;
	}
}

#endif