algorithm

realview22.rar

        __first : _STD::remove_copy_if (++__next, __last, __first, __pred);
}


template <class _InputIter, class _FwdIter>
_FwdIter __unique_copy (_InputIter, _InputIter, _FwdIter, forward_iterator_tag);


template <class _InputIter, class _BidirIter>
inline _BidirIter
__unique_copy (_InputIter __first, _InputIter __last, _BidirIter __res, 
               bidirectional_iterator_tag)
{
    return __unique_copy (__first, __last, __res, forward_iterator_tag ());
}


template <class _InputIter, class _RandomAccessIter>
inline _RandomAccessIter
__unique_copy (_InputIter __first, _InputIter __last,
               _RandomAccessIter __res, random_access_iterator_tag)
{
    return __unique_copy (__first, __last, __res, forward_iterator_tag ());
}

template <class _InputIter, class _OutputIter, class _TypeT>
_OutputIter __unique_copy (_InputIter, _InputIter, _OutputIter, _TypeT*);


template <class _InputIter, class _OutputIter>
inline _OutputIter __unique_copy (_InputIter __first, _InputIter __last,
                                  _OutputIter __res, output_iterator_tag)
{
    return __unique_copy (__first, __last, __res,
                          _RWSTD_VALUE_TYPE (_InputIter));
}


template <class _InputIter, class _OutputIter>
inline _OutputIter
unique_copy (_InputIter __first, _InputIter __last, _OutputIter __res)
{
    return __first == __last ? __res :
        __unique_copy (__first, __last, __res,
                       _RWSTD_ITERATOR_CATEGORY (_OutputIter, __res));
}


template <class _InputIter, class _FwdIter, class _BinaryPredicate>
_FwdIter __unique_copy (_InputIter, _InputIter, _FwdIter, _BinaryPredicate,
                        forward_iterator_tag);


template <class _InputIter, class _BidirIter, class _BinaryPredicate>
inline _BidirIter
__unique_copy (_InputIter __first, _InputIter __last, _BidirIter __res, 
               _BinaryPredicate __pred, bidirectional_iterator_tag)
{
    return __unique_copy (__first, __last, __res, __pred,
                          forward_iterator_tag ());
}


template <class _InputIter, class _RandomAccessIter, class _BinaryPredicate>
inline _RandomAccessIter
__unique_copy (_InputIter __first, _InputIter __last, _RandomAccessIter __res, 
               _BinaryPredicate __pred, random_access_iterator_tag)
{
    return __unique_copy (__first, __last, __res, __pred, 
                          forward_iterator_tag ());
}


template <class _InputIter, class _OutputIter, class _BinaryPredicate,
          class _TypeT>
_OutputIter __unique_copy (_InputIter, _InputIter, _OutputIter,
                           _BinaryPredicate, _TypeT*);

template <class _InputIter, class _OutputIter, class _BinaryPredicate>
inline _OutputIter
__unique_copy (_InputIter __first, _InputIter __last, _OutputIter __res,
               _BinaryPredicate __pred, output_iterator_tag)
{
    return __unique_copy (__first, __last, __res, __pred,
                          _RWSTD_VALUE_TYPE (_InputIter));
}


template <class _InputIter, class _OutputIter, class _BinaryPredicate>
inline _OutputIter
unique_copy (_InputIter __first, _InputIter __last, _OutputIter __res,
             _BinaryPredicate __pred)
{
      return __first == __last ? __res :
          __unique_copy (__first, __last, __res, __pred,
                         _RWSTD_ITERATOR_CATEGORY (_OutputIter, __res));
}


template <class _FwdIter>
inline _FwdIter unique (_FwdIter __first, _FwdIter __last)
{
    __first = _STD::adjacent_find (__first, __last);
    return _STD::unique_copy (__first, __last, __first);
}


template <class _FwdIter, class _BinaryPredicate>
inline _FwdIter unique (_FwdIter __first, _FwdIter __last,
                        _BinaryPredicate __pred)
{
    __first = _STD::adjacent_find (__first, __last, __pred);
    return _STD::unique_copy (__first, __last, __first, __pred);
}


template <class _BidirIter>
void __reverse (_BidirIter, _BidirIter, bidirectional_iterator_tag);


template <class _RandomAccessIter>
void __reverse (_RandomAccessIter __first, _RandomAccessIter __last,
                random_access_iterator_tag);


template <class _BidirIter>
inline void reverse (_BidirIter __first, _BidirIter __last)
{
    __reverse (__first, __last, _RWSTD_ITERATOR_CATEGORY (_BidirIter, __first));
}


template <class _BidirIter, class _OutputIter>
_OutputIter reverse_copy (_BidirIter, _BidirIter, _OutputIter);


template <class _FwdIter, class _Distance>
void __rotate (_FwdIter, _FwdIter, _FwdIter, _Distance*, forward_iterator_tag);


template <class _BidirIter, class _Distance>
inline void
__rotate (_BidirIter __first, _BidirIter __middle, _BidirIter __last,
          _Distance*, bidirectional_iterator_tag)
{
    _STD::reverse (__first, __middle);
    _STD::reverse (__middle, __last);
    _STD::reverse (__first, __last);
}


template <class _EuclideanRingElement>
_EuclideanRingElement __gcd (_EuclideanRingElement, _EuclideanRingElement);


template <class _RandomAccessIter, class _Distance, class _TypeT>
void __rotate_cycle (_RandomAccessIter, _RandomAccessIter, _RandomAccessIter,
                     _Distance, _TypeT*);


template <class _RandomAccessIter, class _Distance>
void __rotate (_RandomAccessIter, _RandomAccessIter, _RandomAccessIter,
               _Distance*, random_access_iterator_tag);


template <class _FwdIter>
inline void rotate (_FwdIter __first, _FwdIter __middle, _FwdIter __last)
{
    if (!(__first == __middle || __middle == __last))
        __rotate (__first, __middle, __last,
                  _RWSTD_DIFFERENCE_TYPE (_FwdIter),
                  _RWSTD_ITERATOR_CATEGORY (_FwdIter, __first));
}


template <class _FwdIter, class _OutputIter>
inline _OutputIter
rotate_copy (_FwdIter __first, _FwdIter __middle, _FwdIter __last,
             _OutputIter __res)
{
    return _STD::copy (__first, __middle, _STD::copy (__middle, __last, __res));
}


template <class _RandomAccessIter, class _Distance>
void __random_shuffle (_RandomAccessIter, _RandomAccessIter, _Distance*);


template <class _RandomAccessIter>
inline void random_shuffle (_RandomAccessIter __first,
                            _RandomAccessIter __last)
{
    __random_shuffle (__first, __last,
                      _RWSTD_DIFFERENCE_TYPE (_RandomAccessIter));
}


template <class _RandomAccessIter, class _RandomNumberGenerator>
void random_shuffle (_RandomAccessIter, _RandomAccessIter,
                     _RandomNumberGenerator&);


template <class _BidirIter, class _Predicate>
_BidirIter partition (_BidirIter, _BidirIter, _Predicate);


template <class _BidirIter, class _Predicate, class _Distance>
_BidirIter
__inplace_stable_partition (_BidirIter, _BidirIter, _Predicate, _Distance);


template <class _BidirIter, class _Pointer, class _Predicate,
          class _Distance, class _TypeT>
_BidirIter
__stable_partition_adaptive (_BidirIter, _BidirIter, _Predicate, _Distance,
                             _Pointer, _Distance, _Distance&, _TypeT*);

template <class _BidirIter, class _Predicate, class _TypeT, class _Distance>
_BidirIter __stable_partition (_BidirIter, _BidirIter, _Predicate,
                               _TypeT*, _Distance*);

template <class _BidirIter, class _Predicate>
inline _BidirIter
stable_partition (_BidirIter __first, _BidirIter __last, _Predicate __pred)
{
    return __stable_partition (__first, __last, __pred,
                               _RWSTD_VALUE_TYPE (_BidirIter),
                               _RWSTD_DIFFERENCE_TYPE (_BidirIter));
}


// 25.3.1 - Sorting [lib.alg.sort]


template <class _RandomAccessIter, class _TypeT, class _Compare>
_RandomAccessIter
__unguarded_partition (_RandomAccessIter, _RandomAccessIter,
                       _TypeT, _Compare);


template <class _RandomAccessIter, class _TypeT, class _Compare>
void __quick_sort_loop_aux (_RandomAccessIter, _RandomAccessIter,
                            _TypeT*, _Compare);


template <class _RandomAccessIter, class _Compare>
inline void
__quick_sort_loop (_RandomAccessIter __first, _RandomAccessIter __last,
                   _Compare __comp)
{
    __quick_sort_loop_aux (__first, __last,
                           _RWSTD_VALUE_TYPE (_RandomAccessIter), __comp);
}


template <class _RandomAccessIter, class _TypeT, class _Compare>
void __unguarded_linear_insert (_RandomAccessIter, _TypeT, _Compare);


template <class _RandomAccessIter, class _TypeT>
inline void __linear_insert (_RandomAccessIter __first, 
                             _RandomAccessIter __last, _TypeT*)
{
    _TypeT __value = *__last;
    if (__value < *__first) {
        _STD::copy_backward (__first, __last, __last + 1);
        *__first = __value;
    }
    else
        __unguarded_linear_insert (__last, __value);
}


template <class _RandomAccessIter, class _TypeT, class _Compare>
inline void
__linear_insert (_RandomAccessIter __first, _RandomAccessIter __last, _TypeT*,
                 _Compare __comp)
{
    _TypeT __value = *__last;
    if (__comp (__value, *__first)) {
        _STD::copy_backward (__first, __last, __last + 1);
        *__first = __value;
    }
    else
        __unguarded_linear_insert(__last, __value, __comp);
}

template <class _RandomAccessIter, class _Compare>
void __insertion_sort (_RandomAccessIter, _RandomAccessIter, _Compare);

template <class _RandomAccessIter, class _Compare>
inline void
__unguarded_insertion_sort (_RandomAccessIter __first, _RandomAccessIter __last,
                            _Compare __comp)
{
    _RWSTD_ASSERT_RANGE (__first, __last);

    for (_RandomAccessIter __i = __first; __i != __last; ++__i)
        __unguarded_linear_insert (__i, *__i, __comp);
}


template <class _RandomAccessIter, class _Distance, class _Compare>
void __introsort_loop (_RandomAccessIter, _RandomAccessIter,
                       _Distance, _Compare);

template <class _RandomAccessIter, class _Compare>
void __final_insertion_sort (_RandomAccessIter, _RandomAccessIter, _Compare);


// 25.3.1.1
template <class _RandomAccessIter, class _Compare>
inline void
sort (_RandomAccessIter __first, _RandomAccessIter __last, _Compare __comp)
{
    if (!(__first == __last))  {
        // introsort guarantees O(N * log(N)) in the worst case
        __introsort_loop (__first, __last, __last - __first, __comp);
        __final_insertion_sort (__first, __last, __comp);
    }
}


template <class _RandomAccessIter>
inline void sort (_RandomAccessIter __first, _RandomAccessIter __last)
{
    _STD::sort (__first, __last, _RWSTD_LESS (_RandomAccessIter));
}


template <class _BidirIter, class _Distance, class _Compare>
void __merge_without_buffer (_BidirIter, _BidirIter, _BidirIter,
                             _Distance, _Distance, _Compare);

template <class _RandomAccessIter, class _Compare>
_INLINE void
__inplace_stable_sort (_RandomAccessIter __first, _RandomAccessIter __last,
                       _Compare __comp)
{
    if (__last - __first < 15)
        __insertion_sort (__first, __last, __comp);
    else {
        _RandomAccessIter __middle = __first + (__last - __first) / 2;
        __inplace_stable_sort (__first, __middle, __comp);
        __inplace_stable_sort (__middle, __last, __comp);
        __merge_without_buffer (__first, __middle, __last,
                                __middle - __first, __last - __middle, __comp);
    }
}


template <class _RandomAccessIter1, class _RandomAccessIter2,
          class _Distance, class _Compare>
void __merge_sort_loop (_RandomAccessIter1, _RandomAccessIter1, 
                        _RandomAccessIter2, _Distance, _Compare);

template <class _RandomAccessIter, class _Distance, class _Compare>
void __chunk_insertion_sort (_RandomAccessIter, _RandomAccessIter, _Distance,
                             _Compare);

template <class _RandomAccessIter, class _Pointer, class _Distance,
          class _TypeT, class _Compare>
void __merge_sort_with_buffer (_RandomAccessIter, _RandomAccessIter,
                               _Pointer, _Distance*, _TypeT*, _Compare);

template <class _RandomAccessIter, class _Pointer, class _Distance,
          class _TypeT, class _Compare>
void __stable_sort_adaptive (_RandomAccessIter, _RandomAccessIter,
                             _Pointer, _Distance, _TypeT*, _Compare);

template <class _RandomAccessIter, class _TypeT, class _Distance,
          class _Compare>