最完整的 9 种常用排序算法 c++ 模板实现_c++不自动排序的模板-优快云博客

本文链接：https://blog.youkuaiyun.com/andy_ro_t/article/details/38401957
本文提供了一组C++模板实现的常见排序算法，包括插入排序、希尔排序、选择排序、冒泡排序、快速排序、二分插入排序、二路归并排序、归并排序（递归法）和堆排序。这些模板适用于不同类型的元素，并可选择升序或降序排列。
摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >
/*
* @note		：9 种常用排序算法 c++ 模板实现
* @author	：Andy.Ro
* @email	：Qwuloo@qq.com
* @date		：2011-04
*
*/

#ifndef _XSORT_H_INCLUDE_
#define _XSORT_H_INCLUDE_

/*
* 函数模板声明 :	template < class _TYPE > RET_TYPE  __name ( ... ) ;
*   类模板声明 :	template < class _TYPE > class  __name ;
* 函数模板特化 :	template < > RET_TYPE  __name < _TYPE > ( ... ) ;
*	类模板特化 :	template < > class  __name < _TYPE > { ... } ;
* 函数模板友元 :	friend RET_TYPE  __name < _TYPE > ( ... ) ;		( 标准版 )
*	类模板友元 :	friend class  __name < _TYPE > ;
* 函数模板调用 :	__name < _TYPE > ( ... ) ;
*/

#define _GT(a, b) ((a) > (b) )
#define _LT(a, b) ((b) > (a) )
#define _EQ(a, b) ((a) == (b))
#define _GE(a, b) (_GT(a, b) || _EQ(a, b))
#define _LE(a, b) (_LT(a, b) || _EQ(a, b))

//------------------------------------------------------------------------
// " > "  " < "  " == "  " >= "  " <= "
template< class _TX, class _TY >
__forceinline bool GT(_TX a, _TY b) { return _GT(a, b); }
template< class _TX, class _TY >
__forceinline bool LT(_TX a, _TY b) { return _LT(a, b); }
template< class _TX, class _TY >
__forceinline bool EQ(_TX a, _TY b) { return _EQ(a, b); }
template< class _TX, class _TY >
__forceinline bool GE(_TX a, _TY b) { return _GE(a, b); }
template< class _TX, class _TY >
__forceinline bool LE(_TX a, _TY b) { return _LE(a, b); }

// reference
template< class _TYPE, class REF_TYPE >
__forceinline REF_TYPE & Ref(_TYPE & o, REF_TYPE *) { return REF_TYPE(o); }

// set
template< class _TYPE, class ARG_TYPE >
__forceinline void Set(_TYPE & a, ARG_TYPE b) { a = b; }

// swap
template< class _TYPE >
__forceinline void Swap(_TYPE & a, _TYPE & b) { _TYPE _t = a; a = b; b = _t; }

// construct
template< class _TYPE >
__forceinline void Construct(_TYPE & o) {}

// destruct
template< class _TYPE >
__forceinline void Destruct (_TYPE & o) {}

//------------------------------------------------------------------------
// xSort<_TYPE,_KEY,_VAL> 节点
//------------------------------------------------------------------------

template< class _TYPE, class _KEY, class _VAL >
class xSort
{
public:
	//------------------------------------------------------------------------
	// @note：插入排序
	static void _insert(_TYPE * const beg, _TYPE * const end, bool const & Desc = false);
	//------------------------------------------------------------------------
	// @note：希尔排序
	static void _shell(_TYPE * const beg, _TYPE * const end, bool const & Desc = false);
	//------------------------------------------------------------------------
	// @note：直接选择
	static void _select(_TYPE * const beg, _TYPE * const end, bool const & Desc = false);
	//------------------------------------------------------------------------
	// @note：冒泡排序
	static void _bubble(_TYPE * const beg, _TYPE * const end, bool const & Desc = false);
	//------------------------------------------------------------------------
	// @note：快速排序
	static void _quick(_TYPE * const beg, _TYPE * const end, bool const & Desc = false);
	//------------------------------------------------------------------------
	// @note：二分插入
	static void _two(_TYPE * const beg, _TYPE * const end, bool const & Desc = false);
	//------------------------------------------------------------------------
	// @note：二路归并
	static void _merge(_TYPE * const beg, _TYPE * const end, bool const & Desc = false);
	//------------------------------------------------------------------------
	// @note：二路归并(递归法)
	static void _merge_r(_TYPE * const beg, _TYPE * const end, bool const & Desc = false);
	//------------------------------------------------------------------------
	// @note：堆排序
	static void _heap(_TYPE * const beg, _TYPE * const end, bool const & Desc = false);
private:
	//------------------------------------------------------------------------
	// @note：快速排序
	static void _quick_r(const _TYPE * const left, const _TYPE * const right, bool const & Desc);
	//------------------------------------------------------------------------
	// @note：有序归并区间 [left, middle] 和 (middle, right]
	static void _merge_range(_TYPE * const dest, /*const*/ _TYPE * const src, const int32 & left, const int32 & middle, const int32 & right, bool const & Desc);
	//------------------------------------------------------------------------
	// @note：一趟归并
	static void _once_merge(_TYPE * const dest, /*const*/ _TYPE * const src, const int32 & range, const int32 & length, bool const & Desc);
	//------------------------------------------------------------------------
	// @note：递归法归并
	static void _merge_r_(_TYPE * const dest, _TYPE * const src, const int32 & left, const int32 & right, bool const & Desc);
private:
	//------------------------------------------------------------------------
	// @note：创建初始堆
	static void _heap_create(_TYPE * const beg, const int32 & index, const int32 & length, bool const & Desc);
};

//------------------------------------------------------------------------
// @note：插入排序

template< class _TYPE, class _KEY, class _VAL >
__forceinline void xSort<_TYPE,_KEY,_VAL>::_insert(_TYPE * const beg, _TYPE * const end, bool const & Desc)
{
	for(_TYPE * _ptr = beg + 1; _ptr != end; ++_ptr)
	{
		_TYPE * _cur = _ptr, *_pre = _cur - 1;
		
		while( _pre != beg - 1 && ( Desc ? GT<_KEY&,_KEY&>(Ref<_TYPE,_KEY>(*_cur,0), Ref<_TYPE,_KEY>(*_pre,0)) : 
										   LT<_KEY&,_KEY&>(Ref<_TYPE,_KEY>(*_cur,0), Ref<_TYPE,_KEY>(*_pre,0)) ) )
		{
			Swap<_VAL>(Ref<_TYPE,_VAL>(*_pre,0), Ref<_TYPE,_VAL>(*_cur--,0));
			_pre = _cur - 1;
		}
	}
}

//------------------------------------------------------------------------
// @note：希尔排序

template< class _TYPE, class _KEY, class _VAL >
__forceinline void xSort<_TYPE,_KEY,_VAL>::_shell(_TYPE * const beg, _TYPE * const end, bool const & Desc)
{
	int32 _len = end - beg;
	
	for(int32 _stp = _len * 0.5; _stp >= 1; _stp *= 0.5)
	{
		for(_TYPE * _ptr = beg + _stp; _ptr < end; _ptr += _stp)
		{
			_TYPE * _cur = _ptr, *_pre = _cur - _stp;
			
			while( _pre != beg - _stp && ( Desc ? GT<_KEY&,_KEY&>(Ref<_TYPE,_KEY>(*_cur,0), Ref<_TYPE,_KEY>(*_pre,0)) : 
												  LT<_KEY&,_KEY&>(Ref<_TYPE,_KEY>(*_cur,0), Ref<_TYPE,_KEY>(*_pre,0)) ) )
			{
				Swap<_VAL>(Ref<_TYPE,_VAL>(*_pre,0), Ref<_TYPE,_VAL>(*_cur,0));
				_cur -= _stp;
				_pre = _cur - _stp;
			}
		}
	}
}

//------------------------------------------------------------------------
// @note：直接选择

template< class _TYPE, class _KEY, class _VAL >
__forceinline void xSort<_TYPE,_KEY,_VAL>::_select(_TYPE * const beg, _TYPE * const end, bool const & Desc)
{
	for(_TYPE * _ptr = beg; _ptr != end - 1; ++_ptr)
	{
		_TYPE * _cur = _ptr, *_cmp = _cur + 1;
		
		for( ; _cmp != end; ++_cmp)
		{
			if( Desc ? GT<_KEY&,_KEY&>(Ref<_TYPE,_KEY>(*_cmp,0), Ref<_TYPE,_KEY>(*_cur,0)) : 
					   LT<_KEY&,_KEY&>(Ref<_TYPE,_KEY>(*_cmp,0), Ref<_TYPE,_KEY>(*_cur,0)) )
			{
				_cur = _cmp;
			}
		}
		Swap<_VAL>(Ref<_TYPE,_VAL>(*_ptr,0), Ref<_TYPE,_VAL>(*_cur,0));
	}
}

//------------------------------------------------------------------------
// @note：冒泡排序

template< class _TYPE, class _KEY, class _VAL >
__forceinline void xSort<_TYPE,_KEY,_VAL>::_bubble(_TYPE * const beg, _TYPE * const end, bool const & Desc)
{
	for(_TYPE * _ptr = end - 1; _ptr != beg; --_ptr)
	{
		bool _lab = false;
		
		for(_TYPE * _cur = beg; _cur != _ptr; ++_cur)
		{
			_TYPE * _nex = _cur + 1;
			
			if( Desc ? GT<_KEY&,_KEY&>(Ref<_TYPE,_KEY>(*_nex,0), Ref<_TYPE,_KEY>(*_cur,0)) : 
					   LT<_KEY&,_KEY&>(Ref<_TYPE,_KEY>(*_nex,0), Ref<_TYPE,_KEY>(*_cur,0)) )
			{
				Swap<_VAL>(Ref<_TYPE,_VAL>(*_nex,0), Ref<_TYPE,_VAL>(*_cur,0));
				_lab = true;
			}
		}
		if( false == _lab ) return;
	}
}

//------------------------------------------------------------------------
// @note：快速排序

template< class _TYPE, class _KEY, class _VAL >
__forceinline void xSort<_TYPE,_KEY,_VAL>::_quick_r(const _TYPE * const left, const _TYPE * const right, bool const & Desc)
{
	_TYPE * _lef = (_TYPE *)left, *_rig = (_TYPE *)right;
	
#if defined(_LEFT_PIVOT)
	
	// 保存临时对象
	_TYPE _tmp(*_lef);
	
	while( _lef < _rig )
	{
		while( _lef < _rig )
		{
			if( Desc ? GE<_KEY&,_KEY&>(Ref<_TYPE,_KEY>(_tmp,0), Ref<_TYPE,_KEY>(*_rig,0)) : 
					   LE<_KEY&,_KEY&>(Ref<_TYPE,_KEY>(_tmp,0), Ref<_TYPE,_KEY>(*_rig,0)) )
			{
				--_rig;
			}
			else
			{
				Set<_VAL,_VAL&>(Ref<_TYPE,_VAL>(*_lef++,0), Ref<_TYPE,_VAL>(*_rig,0));
				break;
			}
		}
		while( _lef < _rig )
		{
			if( Desc ? LE<_KEY&,_KEY&>(Ref<_TYPE,_KEY>(_tmp,0), Ref<_TYPE,_KEY>(*_lef,0)) : 
					   GE<_KEY&,_KEY&>(Ref<_TYPE,_KEY>(_tmp,0), Ref<_TYPE,_KEY>(*_lef,0)) )
			{
				++_lef;
			}
			else
			{
				Set<_VAL,_VAL&>(Ref<_TYPE,_VAL>(*_rig--,0), Ref<_TYPE,_VAL>(*_lef,0));
				break;
			}
		}
	}
	
	Set<_VAL,_VAL&>(Ref<_TYPE,_VAL>(*_lef,0), Ref<_TYPE,_VAL>(_tmp,0));
	
	if( _lef - 1 > left )
	{
		_quick_r(left, _lef - 1, Desc);
	}
	if( _lef + 1 < right )
	{
		_quick_r(_lef + 1, right, Desc);
	}
	
#elif defined(_RIGHT_PIVOT)
	
	// 保存临时对象
	_TYPE _tmp(*_rig);
	
	while( _lef < _rig )
	{
		while( _lef < _rig )
		{
			if( Desc ? LE<_KEY&,_KEY&>(Ref<_TYPE,_KEY>(_tmp,0), Ref<_TYPE,_KEY>(*_lef,0)) : 
					   GE<_KEY&,_KEY&>(Ref<_TYPE,_KEY>(_tmp,0), Ref<_TYPE,_KEY>(*_lef,0)) )
			{
				++_lef;
			}
			else
			{
				Set<_VAL,_VAL&>(Ref<_TYPE,_VAL>(*_rig--,0), Ref<_TYPE,_VAL>(*_lef,0));
				break;
			}
		}
		while( _lef < _rig )
		{
			if( Desc ? GE<_KEY&,_KEY&>(Ref<_TYPE,_KEY>(_tmp,0), Ref<_TYPE,_KEY>(*_rig,0)) : 
					   LE<_KEY&,_KEY&>(Ref<_TYPE,_KEY>(_tmp,0), Ref<_TYPE,_KEY>(*_rig,0)) )
			{
				--_rig;
			}
			else
			{
				Set<_VAL,_VAL&>(Ref<_TYPE,_VAL>(*_lef++,0), Ref<_TYPE,_VAL>(*_rig,0));
				break;
			}
		}
	}
	
	Set<_VAL,_VAL&>(Ref<_TYPE,_VAL>(*_rig,0), Ref<_TYPE,_VAL>(_tmp,0));
	
	if( _rig - 1 > left )
	{
		_quick_r(left, _rig - 1, Desc);
	}
	if( _rig + 1 < right )
	{
		_quick_r(_rig + 1, right, Desc);
	}
	
#else
	
	// 保存临时对象
	_TYPE _tmp(*( _lef + (int32)((_rig - _lef) * 0.5) ));
	
	do{
		while( _lef < right )
		{
			if( Desc ? LT<_KEY&,_KEY&>(Ref<_TYPE,_KEY>(_tmp,0), Ref<_TYPE,_KEY>(*_lef,0)) : 
					   GT<_KEY&,_KEY&>(Ref<_TYPE,_KEY>(_tmp,0), Ref<_TYPE,_KEY>(*_lef,0)) )
			{
				++_lef;
			}
			else break;
		}
		while( _rig > left )
		{
			if( Desc ? GT<_KEY&,_KEY&>(Ref<_TYPE,_KEY>(_tmp,0), Ref<_TYPE,_KEY>(*_rig,0)) : 
					   LT<_KEY&,_KEY&>(Ref<_TYPE,_KEY>(_tmp,0), Ref<_TYPE,_KEY>(*_rig,0)) )
			{
				--_rig;
			}
			else break;
		}
		if( _lef <= _rig )
		{
			Swap<_VAL>(Ref<_TYPE,_VAL>(*_lef++,0), Ref<_TYPE,_VAL>(*_rig--,0));
		}
	}while( _lef <= _rig );
	
	if( _rig > left )
	{
		_quick_r(left, _rig, Desc);
	}
	if( _lef < right )
	{
		_quick_r(_lef, right, Desc);
	}
	
#endif
}

//------------------------------------------------------------------------
// @note：快速排序

template< class _TYPE, class _KEY, class _VAL >
__forceinline void xSort<_TYPE,_KEY,_VAL>::_quick(_TYPE * const beg, _TYPE * const end, bool const & Desc)
{
	_quick_r(beg, end - 1, Desc);
}

//------------------------------------------------------------------------
// @note：二分插入

template< class _TYPE, class _KEY, class _VAL >
__forceinline void xSort<_TYPE,_KEY,_VAL>::_two(_TYPE * const beg, _TYPE * const end, bool const & Desc)
{
	for(_TYPE * _ptr = beg + 1; _ptr != end; ++_ptr)
	{
		_TYPE * _low = beg, *_hig = _ptr;
		
		// 保存临时对象
		_TYPE _tmp(*_ptr);
		
		while( _low <= _hig )
		{
			_TYPE * _mid = beg + (int32)(((_low - beg) + (_hig - beg)) * 0.5);
			
			if( EQ<_KEY&,_KEY&>(Ref<_TYPE,_KEY>(_tmp,0), Ref<_TYPE,_KEY>(*_mid,0)) )
			{
				_low = _mid + 1;
				break;
			}
			if( Desc ? GT<_KEY&,_KEY&>(Ref<_TYPE,_KEY>(_tmp,0), Ref<_TYPE,_KEY>(*_mid,0)) : 
					   LT<_KEY&,_KEY&>(Ref<_TYPE,_KEY>(_tmp,0), Ref<_TYPE,_KEY>(*_mid,0)) )
			{
				_hig = _mid - 1;
			}
			else
			{
				_low = _mid + 1;
			}
		}
		
		if( _low == _ptr ) continue;
		
		for(_TYPE * _cur = _ptr - 1; _cur >= _low; --_cur)
		{
			Set<_VAL,_VAL&>(Ref<_TYPE,_VAL>(*( _cur + 1 ),0), Ref<_TYPE,_VAL>(*_cur,0));
		}
		
		Set<_VAL,_VAL&>(Ref<_TYPE,_VAL>(*_low,0), Ref<_TYPE,_VAL>(_tmp,0));
	}
}

//------------------------------------------------------------------------
// @note：有序归并区间 [left, middle] 和 (middle, right]

template< class _TYPE, class _KEY, class _VAL >
__forceinline void xSort<_TYPE,_KEY,_VAL>::_merge_range(_TYPE * const dest, /*const*/ _TYPE * const src, const int32 & left, const int32 & middle, const int32 & right, bool const & Desc)
{
	int32 _lef = left, _rig = middle + 1, _cur = left;
	
	while( _lef <= middle && _rig <= right )
	{
		Set<_VAL,_VAL&>(Ref<_TYPE,_VAL>(dest[_cur++],0), ( Desc ? GE<_KEY&,_KEY&>(Ref<_TYPE,_KEY>(src[_lef],0), Ref<_TYPE,_KEY>(src[_rig],0)) : 
																  LE<_KEY&,_KEY&>(Ref<_TYPE,_KEY>(src[_lef],0), Ref<_TYPE,_KEY>(src[_rig],0)) ) ? 
																				  Ref<_TYPE,_VAL>(src[_lef++],0) : 
																				  Ref<_TYPE,_VAL>(src[_rig++],0));
	}
	while( _lef <= middle )
	{
		Set<_VAL,_VAL&>(Ref<_TYPE,_VAL>(dest[_cur++],0), Ref<_TYPE,_VAL>(src[_lef++],0));
	}
	while( _rig <= right )
	{
		Set<_VAL,_VAL&>(Ref<_TYPE,_VAL>(dest[_cur++],0), Ref<_TYPE,_VAL>(src[_rig++],0));
	}
}

//------------------------------------------------------------------------
// @note：一趟归并

template< class _TYPE, class _KEY, class _VAL >
__forceinline void xSort<_TYPE,_KEY,_VAL>::_once_merge(_TYPE * const dest, /*const*/ _TYPE * const src, const int32 & range, const int32 & length, bool const & Desc)
{
	int32  _cur = 0, _2_range = range + range;
	
	while( _cur + _2_range - 1 < length )
	{
		_merge_range(dest, src, _cur, _cur + range - 1, _cur + _2_range - 1, Desc);
		_cur += _2_range;
	}
	
	if( _cur + range - 1 < length )
	{
		_merge_range(dest, src, _cur, _cur + range - 1, length - 1, Desc);
	}
	else
	{
		while( _cur < length )
		{
			Set<_VAL,_VAL&>(Ref<_TYPE,_VAL>(dest[_cur++],0), Ref<_TYPE,_VAL>(src[_cur-1],0));
		}
	}
}

//------------------------------------------------------------------------
// @note：二路归并

template< class _TYPE, class _KEY, class _VAL >
__forceinline void xSort<_TYPE,_KEY,_VAL>::_merge(_TYPE * const beg, _TYPE * const end, bool const & Desc)
{
	int32 _len = end - beg, _ran = 1;
	
	_TYPE * _ptr = (_TYPE *)new byte[_len*sizeof(_TYPE)];
	
	while( _ran < _len )
	{
		_once_merge(_ptr, beg, _ran, _len, Desc);  // 一趟归并
		_ran += _ran;                              // 区间长度加倍
		_once_merge(beg, _ptr, _ran, _len, Desc);  // 一趟归并
		_ran += _ran;                              // 区间长度加倍
	}
	
	delete [] _ptr;
}

//------------------------------------------------------------------------
// @note：递归法归并

template< class _TYPE, class _KEY, class _VAL >
__forceinline void xSort<_TYPE,_KEY,_VAL>::_merge_r_(_TYPE * const dest, _TYPE * const src, const int32 & left, const int32 & right, bool const & Desc)
{
	if( left < right )
	{
		int32 middle = (left + right) * 0.5;
		_merge_r_(dest, src, left, middle, Desc);
		_merge_r_(dest, src, middle + 1, right, Desc);
		_merge_range(src, dest, left, middle, right, Desc);
		_merge_range(dest, src, left, middle, right, Desc);
	}
}

//------------------------------------------------------------------------
// @note：二路归并(递归法)

template< class _TYPE, class _KEY, class _VAL >
__forceinline void xSort<_TYPE,_KEY,_VAL>::_merge_r(_TYPE * const beg, _TYPE * const end, bool const & Desc)
{
	int32 _len = end - beg;
	
	_TYPE * _ptr = (_TYPE *)new byte[_len*sizeof(_TYPE)];
	
	_merge_r_(beg, _ptr, 0, _len - 1, Desc);
	
	delete [] _ptr;
}

//------------------------------------------------------------------------
// @note：创建初始堆

template< class _TYPE, class _KEY, class _VAL >
__forceinline void xSort<_TYPE,_KEY,_VAL>::_heap_create(_TYPE * const beg, const int32 & index, const int32 & length, bool const & Desc)
{
	int32 _ptr = index, _cur = _ptr + _ptr + 1;
	
	// 保存临时对象
	_TYPE _tmp(beg[_ptr]);
	
	while( _cur < length )
	{
		int32 _nex = _cur + 1;
		
		if(_cur < length - 1 && ( Desc ? LT<_KEY&,_KEY&>(Ref<_TYPE,_KEY>(beg[_nex],0), Ref<_TYPE,_KEY>(beg[_cur],0)) : 
										 GT<_KEY&,_KEY&>(Ref<_TYPE,_KEY>(beg[_nex],0), Ref<_TYPE,_KEY>(beg[_cur],0)) ) )
		{
			++_cur;
		}
		if( Desc ? GT<_KEY&,_KEY&>(Ref<_TYPE,_KEY>(_tmp,0), Ref<_TYPE,_KEY>(beg[_cur],0)) : 
				   LT<_KEY&,_KEY&>(Ref<_TYPE,_KEY>(_tmp,0), Ref<_TYPE,_KEY>(beg[_cur],0)) )
		{
			Set<_VAL,_VAL&> (Ref<_TYPE,_VAL>(beg[_ptr],0), Ref<_TYPE,_VAL>(beg[_cur],0));
			_ptr = _cur;
			_cur = _ptr + _ptr + 1;
		}
		else break;
	}
	Set<_VAL,_VAL&>(Ref<_TYPE,_VAL>(beg[_ptr],0), Ref<_TYPE,_VAL>(_tmp,0));
}

//------------------------------------------------------------------------
// @note：堆排序

template< class _TYPE, class _KEY, class _VAL >
__forceinline void xSort<_TYPE,_KEY,_VAL>::_heap(_TYPE * const beg, _TYPE * const end, bool const & Desc)
{
	int32 _len = end - beg, _cur = (_len - 1) * 0.5; 
	
	for( ; _cur >= 0; --_cur)
	{
		_heap_create(beg, _cur, _len, Desc);
	}
	for(_cur = _len - 1; _cur >= 0; --_cur)
	{
		Swap<_VAL>(Ref<_TYPE,_VAL>(beg[_cur],0), Ref<_TYPE,_VAL>(beg[0],0));
		_heap_create(beg, 0, _cur, Desc);
	}
}

#endif // _XSORT_H_INCLUDE_