来自<algorithm> c++自带排序sort的提取代码 | 内观排序模板

作死尝试提取STL..

#include <cstdio>
#include <cstdlib>

namespace std {

struct input_iterator_tag {};
struct output_iterator_tag {};
struct forward_iterator_tag : public input_iterator_tag {};
struct bidirectional_iterator_tag : public forward_iterator_tag {};
struct random_access_iterator_tag : public bidirectional_iterator_tag {};

enum { _S_threshold = 16 };

struct __true_type {};
struct __false_type {};

template <class _Tp>
struct __type_traits {
typedef __true_type this_dummy_member_must_be_first;
typedef __false_type has_trivial_default_constructor;
typedef __false_type has_trivial_copy_constructor;
typedef __false_type has_trivial_assignment_operator;
typedef __false_type has_trivial_destructor;
typedef __false_type is_POD_type;
};

template<typename _Iterator>
struct iterator_traits {
typedef typename _Iterator::iterator_category iterator_category;
typedef typename _Iterator::value_type value_type;
typedef typename _Iterator::difference_type difference_type;
typedef typename _Iterator::pointer pointer;
typedef typename _Iterator::reference reference;
};

template<typename _Tp>
struct iterator_traits<_Tp*>
{
typedef random_access_iterator_tag iterator_category;
typedef _Tp value_type;
typedef ptrdiff_t difference_type;
typedef _Tp* pointer;
typedef _Tp& reference;
};
template <class _Iter>
inline typename iterator_traits<_Iter>::iterator_category
iterator_category(const _Iter& __i)
{ return __iterator_category(__i); }

template <class _Iter>
inline typename iterator_traits<_Iter>::difference_type* distance_type(const _Iter&)
{ return static_cast<typename iterator_traits<_Iter>::difference_type*>(0); }

template<class _Iter>
inline typename iterator_traits<_Iter>::value_type* value_type(const _Iter& __i)
{ return static_cast<typename iterator_traits<_Iter>::value_type*>(0); }

template<typename _Iter>
inline typename iterator_traits<_Iter>::iterator_category __iterator_category(const _Iter&)
{ return typename iterator_traits<_Iter>::iterator_category(); }

template<typename _Tp>
inline const _Tp& __median(const _Tp& __a, const _Tp& __b, const _Tp& __c) {
if (__a < __b)
if (__b < __c) return __b;
else if (__a < __c) return __c;
else return __a;
else if (__a < __c) return __a;
else if (__b < __c) return __c;
else return __b;
}

template<typename _Tp, typename _Compare>
inline const _Tp& __median(const _Tp& __a, const _Tp& __b, const _Tp& __c, _Compare __comp) {
if (__comp(__a, __b))
if (__comp(__b, __c)) return __b;
else if (__comp(__a, __c)) return __c;
else return __a;
else if (__comp(__a, __c)) return __a;
else if (__comp(__b, __c)) return __c;
else return __b;
}

template<typename _ForwardIterator1, typename _ForwardIterator2>
inline void iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b) {
typedef typename iterator_traits<_ForwardIterator1>::value_type _ValueType1;
typedef typename iterator_traits<_ForwardIterator2>::value_type _ValueType2;

const _ValueType1 __tmp = *__a;
*__a = *__b;
*__b = __tmp;
}

template<typename _RandomAccessIterator, typename _Tp>
_RandomAccessIterator __unguarded_partition(_RandomAccessIterator __first,
_RandomAccessIterator __last, _Tp __pivot) {
while (1) {
while (*__first < __pivot) ++__first;
--__last;
while (__pivot < *__last) --__last;
if (!(__first < __last))
return __first;
iter_swap(__first, __last);
++__first;
}
}
template<typename _Size>
inline _Size __lg(_Size __n) {
_Size __k;
for (__k = 0; __n != 1; __n >>= 1) ++__k;
return __k;
}

template<typename _RandomAccessIterator, typename _Tp>
void __unguarded_linear_insert(_RandomAccessIterator __last, _Tp __val) {
_RandomAccessIterator __next = __last;
--__next;
while (__val < *__next) {
*__last = *__next;
__last = __next;
--__next;
}
*__last = __val;
}

template<typename _Tp>
struct _Is_normal_iterator {
typedef __false_type _Normal;
};

template<typename _BidirectionalIterator1, typename _BidirectionalIterator2>
inline _BidirectionalIterator2 __copy_backward(_BidirectionalIterator1 __first,
_BidirectionalIterator1 __last, _BidirectionalIterator2 __result,
bidirectional_iterator_tag) {
while (__first != __last) *--__result = *--__last;
return __result;
}

template<typename _BidirectionalIterator1, typename _BidirectionalIterator2, typename _BoolType>
struct __copy_backward_dispatch {
static _BidirectionalIterator2
copy(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last, _BidirectionalIterator2 __result)
{ return __copy_backward(__first, __last, __result, __iterator_category(__first)); }
};

template<typename _Tp>
struct __copy_backward_dispatch<_Tp*, _Tp*, __true_type> {
static _Tp* copy(const _Tp* __first, const _Tp* __last, _Tp* __result) {
const ptrdiff_t _Num = __last - __first;
memmove(__result - _Num, __first, sizeof(_Tp) * _Num);
return __result - _Num;
}
};

template<typename _Tp>
struct __copy_backward_dispatch<const _Tp*, _Tp*, __true_type> {
static _Tp* copy(const _Tp* __first, const _Tp* __last, _Tp* __result) {
return std::__copy_backward_dispatch<_Tp*, _Tp*, __true_type>::copy(__first, __last, __result);
}
};

template<typename _BI1, typename _BI2>
inline _BI2 __copy_backward_aux(_BI1 __first, _BI1 __last, _BI2 __result) {
typedef typename __type_traits<typename iterator_traits<_BI2>::value_type>
::has_trivial_assignment_operator _Trivial;
return __copy_backward_dispatch<_BI1, _BI2, _Trivial>::copy(__first,
__last, __result);
}

template <typename _BI1, typename _BI2>
inline _BI2 __copy_backward_output_normal_iterator(_BI1 __first, _BI1 __last,
_BI2 __result, __true_type)
{ return _BI2(__copy_backward_aux(__first, __last, __result.base())); }

template <typename _BI1, typename _BI2>
inline _BI2 __copy_backward_output_normal_iterator(_BI1 __first, _BI1 __last,
_BI2 __result, __false_type)
{ return __copy_backward_aux(__first, __last, __result); }

template <typename _BI1, typename _BI2>
inline _BI2 __copy_backward_input_normal_iterator(_BI1 __first, _BI1 __last,
_BI2 __result, __true_type) {
typedef typename _Is_normal_iterator<_BI2>::_Normal __Normal;
return __copy_backward_output_normal_iterator(__first.base(),
__last.base(), __result, __Normal());
}

template <typename _BI1, typename _BI2>
inline _BI2 __copy_backward_input_normal_iterator(_BI1 __first, _BI1 __last,
_BI2 __result, __false_type) {
typedef typename _Is_normal_iterator<_BI2>::_Normal __Normal;
return __copy_backward_output_normal_iterator(__first, __last, __result, __Normal());
}

template <typename _BI1, typename _BI2>
inline _BI2 copy_backward(_BI1 __first, _BI1 __last, _BI2 __result) {
typedef typename _Is_normal_iterator<_BI1>::_Normal __Normal;
return __copy_backward_input_normal_iterator(__first, __last,
__result, __Normal());
}

template<typename _RandomAccessIterator>
void __insertion_sort(_RandomAccessIterator __first,
_RandomAccessIterator __last) {
if (__first == __last) return;

for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i) {
typename iterator_traits<_RandomAccessIterator>::value_type
__val = *__i;
if (__val < *__first) {
copy_backward(__first, __i, __i + 1);
*__first = __val;
}
else __unguarded_linear_insert(__i, __val);
}
}

template<typename _RandomAccessIterator>
inline void __unguarded_insertion_sort(_RandomAccessIterator __first,
_RandomAccessIterator __last) {
typedef typename iterator_traits<_RandomAccessIterator>::value_type
_ValueType;

for (_RandomAccessIterator __i = __first; __i != __last; ++__i)
__unguarded_linear_insert(__i, _ValueType(*__i));
}

template<typename _RandomAccessIterator>
void __final_insertion_sort(_RandomAccessIterator __first,
_RandomAccessIterator __last) {
if (__last - __first > _S_threshold)
{
__insertion_sort(__first, __first + _S_threshold);
__unguarded_insertion_sort(__first + _S_threshold, __last);
}
else __insertion_sort(__first, __last);
}

template<typename _RandomAccessIterator>
inline void sort(_RandomAccessIterator __first,
_RandomAccessIterator __last) {
if (__first != __last) {
__introsort_loop(__first, __last, __lg(__last - __first) * 2);
__final_insertion_sort(__first, __last);
}
}

template<typename _RandomAccessIterator, typename _Distance, typename _Tp,
typename _Compare>
void __push_heap(_RandomAccessIterator __first, _Distance __holeIndex,
_Distance __topIndex, _Tp __value, _Compare __comp) {
_Distance __parent = (__holeIndex - 1) / 2;
while (__holeIndex > __topIndex
&& __comp(*(__first + __parent), __value)) {
*(__first + __holeIndex) = *(__first + __parent);
__holeIndex = __parent;
__parent = (__holeIndex - 1) / 2;
}
*(__first + __holeIndex) = __value;
}

template<typename _RandomAccessIterator, typename _Compare>
inline void push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp) {
typedef typename iterator_traits<_RandomAccessIterator>::value_type
_ValueType;
typedef typename iterator_traits<_RandomAccessIterator>::difference_type
_DistanceType;

__push_heap(__first, _DistanceType((__last - __first) - 1),
_DistanceType(0), _ValueType(*(__last - 1)), __comp);
}

template<typename _RandomAccessIterator, typename _Distance, typename _Tp>
void __push_heap(_RandomAccessIterator __first, _Distance __holeIndex,
_Distance __topIndex, _Tp __value) {
_Distance __parent = (__holeIndex - 1) / 2;
while (__holeIndex > __topIndex && *(__first + __parent) < __value) {
*(__first + __holeIndex) = *(__first + __parent);
__holeIndex = __parent;
__parent = (__holeIndex - 1) / 2;
}
*(__first + __holeIndex) = __value;
}

template<typename _RandomAccessIterator>
void make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
{
typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
typedef typename iterator_traits<_RandomAccessIterator>::difference_type _DistanceType;

if (__last - __first < 2) return;

const _DistanceType __len = __last - __first;
_DistanceType __parent = (__len - 2) / 2;
while (1) {
__adjust_heap(__first, __parent, __len,
_ValueType(*(__first + __parent)));
if (__parent == 0)
return;
__parent--;
}
}

template<typename _RandomAccessIterator, typename _Distance,
typename _Tp, typename _Compare>
void __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
_Distance __len, _Tp __value, _Compare __comp) {
const _Distance __topIndex = __holeIndex;
_Distance __secondChild = 2 * __holeIndex + 2;
while (__secondChild < __len) {
if (__comp(*(__first + __secondChild),
*(__first + (__secondChild - 1))))
__secondChild--;
*(__first + __holeIndex) = *(__first + __secondChild);
__holeIndex = __secondChild;
__secondChild = 2 * (__secondChild + 1);
}
if (__secondChild == __len) {
*(__first + __holeIndex) = *(__first + (__secondChild - 1));
__holeIndex = __secondChild - 1;
}
__push_heap(__first, __holeIndex, __topIndex, __value, __comp);
}

template<typename _RandomAccessIterator, typename _Distance, typename _Tp>
void __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
_Distance __len, _Tp __value) {
const _Distance __topIndex = __holeIndex;
_Distance __secondChild = 2 * __holeIndex + 2;
while (__secondChild < __len) {
if (*(__first + __secondChild) < *(__first + (__secondChild - 1)))
__secondChild--;
*(__first + __holeIndex) = *(__first + __secondChild);
__holeIndex = __secondChild;
__secondChild = 2 * (__secondChild + 1);
}
if (__secondChild == __len) {
*(__first + __holeIndex) = *(__first + (__secondChild - 1));
__holeIndex = __secondChild - 1;
}
__push_heap(__first, __holeIndex, __topIndex, __value);
}

template<typename _RandomAccessIterator, typename _Tp, typename _Compare>
inline void __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
_RandomAccessIterator __result, _Tp __value, _Compare __comp) {
typedef typename iterator_traits<_RandomAccessIterator>::difference_type
_Distance;
*__result = *__first;
__adjust_heap(__first, _Distance(0), _Distance(__last - __first),
__value, __comp);
}

template<typename _RandomAccessIterator, typename _Tp>
inline void __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
_RandomAccessIterator __result, _Tp __value) {
typedef typename iterator_traits<_RandomAccessIterator>::difference_type _Distance;
*__result = *__first;
__adjust_heap(__first, _Distance(0), _Distance(__last - __first), __value);
}

template<typename _RandomAccessIterator>
inline void pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) {
typedef typename iterator_traits<_RandomAccessIterator>::value_type
_ValueType;

__pop_heap(__first, __last - 1, __last - 1,
_ValueType(*(__last - 1)));
}

template<typename _RandomAccessIterator>
void sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) {
while (__last - __first > 1) pop_heap(__first, __last--);
}

template<typename _RandomAccessIterator>
void partial_sort(_RandomAccessIterator __first,
_RandomAccessIterator __middle,
_RandomAccessIterator __last) {
typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
make_heap(__first, __middle);
for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)
if (*__i < *__first)
__pop_heap(__first, __middle, __i, _ValueType(*__i));
sort_heap(__first, __middle);
}

template<typename _RandomAccessIterator, typename _Size>
void __introsort_loop(_RandomAccessIterator __first,
_RandomAccessIterator __last,
_Size __depth_limit) {
typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType;
while (__last - __first > _S_threshold) {
if (__depth_limit == 0) {
partial_sort(__first, __last, __last);
return;
}
--__depth_limit;
_RandomAccessIterator __cut =
__unguarded_partition(__first, __last, _ValueType(__median(*__first, *(__first + (__last - __first) / 2), *(__last - 1))));
__introsort_loop(__cut, __last, __depth_limit);
__last = __cut;
}
}
}

int main() {
int a[] = {2, 3, 4, 1, 5};
std::sort(a, a+5);
for(int i=0;i<5;i++)printf("%d ", a[i]);
system("pause");
return 0;
}