Поменять местами две серии в массиве.

#include <algorithm>
#include <functional>
#include <vector>
#include <iterator>
#include <locale>
#include <iostream>
 
template <typename T>
struct finder : public std::unary_function<T, bool>
{
    typedef typename std::iterator_traits<typename T::value_type::first_type>::value_type value_type;
 
    finder(value_type v) : v_(v) {}
    
    bool operator()(const typename T::value_type& v) const
    {
        return *v.first == v_;
    }
 
    const value_type v_;
};
 
template <typename T>
void mutate_sequance(T begin, T end)
{
    typedef typename std::iterator_traits<T>::value_type value_type;    
    
    typedef std::vector<std::pair<T, T> > V;
    V v;
    
    T curr = begin, next;
    for(; (next = std::adjacent_find(curr, end, std::not2(std::equal_to<value_type>()))) != end; curr = ++next)
        v.push_back(std::make_pair(curr, next+1));
 
    v.push_back(std::make_pair(curr, next));
 
    typename V::iterator _1 = std::find_if(v.begin(), v.end(), finder<V>(2));
    typename V::iterator _2 = std::find_if(v.begin(), v.end(), finder<V>(5));
    std::iter_swap(_1, _2);
 
    std::cout << "После:\t";
    for (typename V::const_iterator it = v.begin(); it != v.end(); ++it)
        std::copy(it->first, it->second, std::ostream_iterator<value_type>(std::cout, " "));
    std::cout << std::endl;
}
 
int main()
{
    setlocale(LC_ALL, "");
    int arr[] = {1,1,1,2,3,3,4,4,4,5,5,5,6};
    const size_t N = sizeof(arr) / sizeof(arr[0]);
 
    std::vector<std::pair<const int*, const int*> > v;
 
    std::cout << "До:\t";
    std::copy(arr, arr+N, std::ostream_iterator<int>(std::cout, " "));
    std::cout << std::endl;
 
    mutate_sequance(arr, arr+N);
 
    return 0;
}

#include <algorithm>
#include <functional>
 
template<typename _RndIt, typename _Tr = std::iterator_traits<_RndIt> > class Swap_seq
{
public:
    typedef typename _Tr::value_type value_type;
    typedef std::reverse_iterator<_RndIt> Rev_iter;
 
    static void swap_seq( _RndIt first, _RndIt last, value_type v_1, value_type v_2 )
    {
        _RndIt begin_1 = std::find( first, last, v_1 );
        _RndIt end_1 = std::find( Rev_iter(last), Rev_iter(first), v_1 ).base();
        typename _Tr::difference_type count_1 = std::count( first, last, v_1 );
 
        _RndIt begin_2 = std::find( first, last, v_2 );
        _RndIt end_2 = std::find( Rev_iter(last), Rev_iter(first), v_2 ).base();
       typename _Tr::difference_type count_2 = std::count( first, last, v_2 );
 
      if( count_1 > count_2 )
      {
          while( count_1-- != 0 )
              std::swap( *(begin_1++), *(--end_2) );
      }
      else
      {
          while( count_2-- != 0 )
              std::swap( *(begin_1++), *(--end_2) );
      }
 
    }
};
 
int _tmain( int argc, _TCHAR* argv[] )
{
    int coll[] = { 1, 1, 1, 2, 3, 3, 8, 8, 9, 9, 9 };
       const size_t size = sizeof(coll)/sizeof(int);
 
    Swap_seq<int*>::swap_seq( coll, coll + size, 2, 9 );
 
}