好像兼容性很差 有时候能用有时候不能用 难受

测试时间程序(按刻计算)

#include<stdio.h>
#include<iterator>
#include<ctime>

__lg(unsigned long long __n) {
	
	return 8 * __CHAR_BIT__ - 1 - __builtin_clzll(__n);
}

template
<
	typename _RandomAccessIterator,
	typename _Distance,
	typename _Tp,
    typename _Compare
>

inline 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) == true) {
		
		*(__first + __holeIndex) = _GLIBCXX_MOVE( *(__first + __parent) );
		
		__holeIndex = __parent;
		__parent = (__holeIndex - 1) / 2;
	}
	
	*(__first + __holeIndex) = _GLIBCXX_MOVE(__value);
	
	return;
}

template
<
	typename _RandomAccessIterator,
	typename _Distance,
    typename _Tp,
	typename _Compare
>

inline void __adjust_heap
(
	_RandomAccessIterator __first,
	_Distance __holeIndex,
    _Distance __len,
	_Tp __value,
	_Compare __comp
)

{
	const _Distance __topIndex = __holeIndex;
	_Distance __secondChild = __holeIndex;
	
	while (__secondChild < (__len - 1) / 2) {
		
		__secondChild = 2 * (__secondChild + 1);
		
		if (__comp (__first + __secondChild, __first + (__secondChild - 1)) ) {
			
			__secondChild--;
		}
			
		*(__first + __holeIndex) = _GLIBCXX_MOVE( *(__first + __secondChild) );
		__holeIndex = __secondChild;
	}
	
	if ( (__len & 1) == 0 && __secondChild == (__len - 2) / 2 ) {
		
		__secondChild = 2 * (__secondChild + 1);
		
		*(__first + __holeIndex) = _GLIBCXX_MOVE( *(__first + (__secondChild - 1)) );
		                           
		__holeIndex = __secondChild - 1;
	}
	
	__push_heap
	(
		__first,
		__holeIndex,
		__topIndex,
	    _GLIBCXX_MOVE(__value),
	    __gnu_cxx::__ops::__iter_comp_val(__comp)
	);
	            
	return;
}

template
<
	typename _RandomAccessIterator,
	typename _Compare
>

inline void __pop_heap
(
	_RandomAccessIterator __first,
	_RandomAccessIterator __last,
    _RandomAccessIterator __result,
	_Compare __comp
)

{
	typedef typename std::iterator_traits<_RandomAccessIterator>::value_type
	_ValueType;
	
	typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type
	_DistanceType;

	_ValueType __value = _GLIBCXX_MOVE(*__result);
	*__result = _GLIBCXX_MOVE(*__first);
	
	__adjust_heap
	(
		__first, _DistanceType(0),
		_DistanceType(__last - __first),
	    _GLIBCXX_MOVE(__value), __comp
	);
	              
	return;
}

template
<
	typename _RandomAccessIterator,
	typename _Compare
>

inline void __make_heap
(
	_RandomAccessIterator __first,
	_RandomAccessIterator __last,
    _Compare __comp
)

{
	typedef typename std::iterator_traits<_RandomAccessIterator>::value_type
	_ValueType;
	
	typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type
	_DistanceType;

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

template
<
	typename _RandomAccessIterator,
	typename _Compare
>

inline void __heap_select
(
	_RandomAccessIterator __first,
    _RandomAccessIterator __middle,
    _RandomAccessIterator __last,
	_Compare __comp
)

{
	__make_heap
	(
		__first,
		__middle,
		__comp
	);
	
	for (_RandomAccessIterator __i = __middle; __i < __last; ++__i) {
		
		if (__comp(__i, __first) == true) {
			
			__pop_heap
			(
				__first,
				__middle,
				__i,
				__comp
			);
		}
	}
			
	return;
}

template
<
	typename _RandomAccessIterator,
	typename _Compare
>

inline void __sort_heap
(
	_RandomAccessIterator __first,
	_RandomAccessIterator __last,
	_Compare __comp
) 

{
	while (__last - __first > 1) {
		
		--__last;
		
		__pop_heap
		(
			__first,
			__last,
			__last,
			__comp
		);
	}
	
	return;
}

template
<
	typename _Iterator,
	typename _Compare
>

inline void __move_median_to_first
(
	_Iterator __result,
	_Iterator __a,
	_Iterator __b,
    _Iterator __c,
	_Compare __comp
)

{
	if (__comp(__a, __b) == true) {
		
		if (__comp(__b, __c) == true) {
			
			std::iter_swap(__result, __b);
		}
			
		else if (__comp(__a, __c) == true) {
			
			std::iter_swap(__result, __c);
		}
			
		else{
			
			std::iter_swap(__result, __a);
		}
	} 
	
	else if (__comp(__a, __c) == true) {
		
		std::iter_swap(__result, __a);
	}
		
	else if (__comp(__b, __c)) {
		
		std::iter_swap(__result, __c);
	}
		
	else{
		
		std::iter_swap(__result, __b);
	}
		
	return;
}

template
<
	typename _RandomAccessIterator,
	typename _Compare
>

inline _RandomAccessIterator __unguarded_partition
(
	_RandomAccessIterator __first,
    _RandomAccessIterator __last,
    _RandomAccessIterator __pivot,
	_Compare __comp
)

{
	while (true) {
		
		while (__comp(__first, __pivot) == true) {
			
			++__first;
		}
			
		--__last;
		
		while (__comp(__pivot, __last) == true) {
			
			--__last;
		}
			
		if (__first < __last == false) {
			
			return __first;
		}
			
		std::iter_swap
		(
			__first,
			__last
		);
		
		++__first;
	}
}

template
<
	typename _RandomAccessIterator,
	typename _Compare
>

inline _RandomAccessIterator __unguarded_partition_pivot
(
	_RandomAccessIterator __first,
    _RandomAccessIterator __last,
	_Compare __comp
)

{
	_RandomAccessIterator __mid = __first + (__last - __first) / 2;
	
	__move_median_to_first
	(
		__first,
		__first + 1,
		__mid,
		__last - 1,
		__comp
	);
	
	return __unguarded_partition
	(
		__first + 1,
		__last,
		__first,
		__comp
	);
}

template
<
	typename _RandomAccessIterator,
	typename _Compare
>

inline void __partial_sort
(
	_RandomAccessIterator __first,
	_RandomAccessIterator __middle,
	_RandomAccessIterator __last,
	_Compare __comp
)

{
    __heap_select
	(
		__first,
		__middle,
		__last,
		__comp
	);
	
    __sort_heap
	(
		__first,
		__middle,
		__comp
	);
	
	return;
}

template
<
	typename _RandomAccessIterator,
	typename _Compare
>

inline void __unguarded_linear_insert
(
	_RandomAccessIterator __last,
    _Compare __comp
)

{
	typename std::iterator_traits<_RandomAccessIterator>::value_type
	__val = _GLIBCXX_MOVE(*__last);
	
	_RandomAccessIterator __next = __last;
	--__next;
	
	while (__comp(__val, __next) == true) {
		
		*__last = _GLIBCXX_MOVE(*__next);
		__last = __next;
		
		--__next;
	}
	
	*__last = _GLIBCXX_MOVE(__val);
	
	return;
}

template
<
	typename _RandomAccessIterator,
	typename _Compare
>

inline void __insertion_sort
(
	_RandomAccessIterator __first,
    _RandomAccessIterator __last,
	_Compare __comp
)

{
	if (__first == __last) {
		
		return;
	}

	for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i) {
		
		if (__comp(__i, __first) == true) {
			
			typename std::iterator_traits<_RandomAccessIterator>::value_type
			__val = _GLIBCXX_MOVE(*__i);
			
			_GLIBCXX_MOVE_BACKWARD3
			(
				__first,
				__i,
				__i + 1
			);
			
			*__first = _GLIBCXX_MOVE(__val);
		}
		
		else{
			
			__unguarded_linear_insert
			(
				__i,
				__gnu_cxx::__ops::__val_comp_iter(__comp)
			);
		}
	}
	
	return;
}

template
<
	typename _RandomAccessIterator,
	typename _Compare
>

inline void __unguarded_insertion_sort
(
	_RandomAccessIterator __first,
    _RandomAccessIterator __last,
	_Compare __comp
)

{
	for (_RandomAccessIterator __i = __first; __i != __last; ++__i) {
		
		__unguarded_linear_insert
		(
			__i,
		    __gnu_cxx::__ops::__val_comp_iter(__comp)
		);
	}
		                          
	return;	                          
}

template
<
	typename _RandomAccessIterator,
	typename _Compare
>

inline void __final_insertion_sort
(
	_RandomAccessIterator __first,
    _RandomAccessIterator __last,
	_Compare __comp
)

{
	if (__last - __first > 16) {
		
		__insertion_sort
		(
			__first,
			__first + 16,
			__comp
		);
		
		__unguarded_insertion_sort
		(
			__first + 16,
			__last,
			__comp
		);
	} 
	
	else {
		
		__insertion_sort
		(
			__first,
			__last,
			__comp
		);
	}
	
	return;
}

template
<
	typename _RandomAccessIterator,
	typename _Size,
	typename _Compare
>

inline void __introsort_loop
(
	_RandomAccessIterator __first,
	_RandomAccessIterator __last,
	_Size __depth_limit,
	_Compare __comp
)

{
    while (__last - __first > 16) {
    	
    	if (__depth_limit == 0) {
	  	
	    	__partial_sort
			(
				__first,
				__last,
				__last,
				__comp
			);
	    	
			return;
		} 
		
		--__depth_limit;
		
		_RandomAccessIterator __cut = 
		__unguarded_partition_pivot
		(
			__first,
			__last,
			__comp
		);
		
		__introsort_loop
		(
			__cut,
			__last,
			__depth_limit,
			__comp
		);
		
		__last = __cut;
	}
	
	return;
}

template
<
	typename _RandomAccessIterator,
	typename _Compare
> 

inline void __sort
(
	_RandomAccessIterator __first,
	_RandomAccessIterator __last,
	_Compare __comp
) 

{
	
	if (__first != __last) {
		
		__introsort_loop
		(
			__first, __last,
			__lg(__last - __first) * 2,
			__comp
		);
		                 
		__final_insertion_sort(__first, __last, __comp);
	}
	
	return;
}

template<typename _RandomAccessIterator>

inline void sort
(
	_RandomAccessIterator __first,
	_RandomAccessIterator __last
)

{
	__glibcxx_function_requires
	(_Mutable_RandomAccessIteratorConcept<_RandomAccessIterator>)
	
	__glibcxx_function_requires
	(
		_LessThanComparableConcept
		<typename iterator_traits<_RandomAccessIterator>::value_type>
	)
	
	__glibcxx_requires_valid_range(__first, __last);

	__sort(__first, __last, __gnu_cxx::__ops::__iter_less_iter());
	
	return;
}

template
<
	typename _RandomAccessIterator,
	typename _Compare
>

inline void sort
(
	_RandomAccessIterator __first,
	_RandomAccessIterator __last,
	_Compare __comp
) 

{
	__glibcxx_function_requires
	(_Mutable_RandomAccessIteratorConcept<_RandomAccessIterator>)
	
	__glibcxx_function_requires
	(
		_BinaryPredicateConcept
		<
			_Compare,
			typename iterator_traits<_RandomAccessIterator>::value_type,
			typename iterator_traits<_RandomAccessIterator>::value_type
		>
	)
	
	__glibcxx_requires_valid_range(__first, __last);

	__sort(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp));
	
	return;
}

int a[100000000],cnt = 0;
unsigned long long Begin,End;

int main() {
	
	for(int i = 1,j = 100000000; i <= j; ++i,--j) {
		
		a[cnt++] = i;
		a[cnt++] = j;
	}
	
	Begin = clock();
	
	sort(a, a + 100000000);
	
	End = clock();
	
	printf("%llu",End - Begin);
	
	return 0;
}

难怪我写的排序没有算法库里的快 10000多个字谁干得过