std::random_shuffle, std::shuffle

template< class RandomIt >
void random_shuffle( RandomIt first, RandomIt last );

template< class RandomIt, class RandomFunc >
void random_shuffle( RandomIt first, RandomIt last, RandomFunc& r );

template< class RandomIt, class RandomFunc >
void random_shuffle( RandomIt first, RandomIt last, RandomFunc&& r );

template< class RandomIt, class URBG >
void shuffle( RandomIt first, RandomIt last, URBG&& g );

Reordena los elementos en el rango dado [first, last) de modo que cada posible permutación de esos elementos tenga igual probabilidad de aparición.

Si el tipo de *first no es Swappable(hasta C++11)RandomIt no es ValueSwappable(desde C++11), el comportamiento no está definido.

Parámetros

Complejidad

Exactamente std::distance(first, last) - 1 intercambios.

Posible implementación

Véase también las implementaciones en libstdc++ y libc++.

template<class RandomIt>
void random_shuffle(RandomIt first, RandomIt last)
{
    typedef typename std::iterator_traits<RandomIt>::difference_type diff_t;
    
    for (diff_t i = last - first - 1; i > 0; --i)
    {
        using std::swap;
        swap(first[i], first[std::rand() % (i + 1)]);
        // rand() % (i + 1) is not actually correct, because the generated number is
        // not uniformly distributed for most values of i. The correct code would be
        // a variation of the C++11 std::uniform_int_distribution implementation.
    }
}

template<class RandomIt, class RandomFunc>
void random_shuffle(RandomIt first, RandomIt last, RandomFunc&& r)
{
    typedef typename std::iterator_traits<RandomIt>::difference_type diff_t;
    
    for (diff_t i = last - first - 1; i > 0; --i)
    {
        using std::swap;
        swap(first[i], first[r(i + 1)]);
    }
}

template<class RandomIt, class URBG>
void shuffle(RandomIt first, RandomIt last, URBG&& g)
{
    typedef typename std::iterator_traits<RandomIt>::difference_type diff_t;
    typedef std::uniform_int_distribution<diff_t> distr_t;
    typedef typename distr_t::param_type param_t;
    
    distr_t D;
    for (diff_t i = last - first - 1; i > 0; --i)
    {
        using std::swap;
        swap(first[i], first[D(g, param_t(0, i))]);
    }
}

Notas

Tenga en cuenta que la implementación no está dictada por el estándar, por lo que incluso si se usa exactamente el mismo RandomFunc o URBG (Generador de Números Aleatorios Uniformes) puede obtener resultados diferentes con diferentes implementaciones de la biblioteca estándar.

La razón para eliminar std::random_shuffle en C++17 es que la versión solo con iteradores normalmente depende de std::rand, que ahora también se discute para su eliminación. (std::rand debería ser reemplazado por las clases del encabezado <random>, ya que std::rand es considerado dañino.) Además, la versión std::random_shuffle solo con iteradores normalmente depende de un estado global. El algoritmo shuffle de std::shuffle es el reemplazo preferido, ya que usa un URBG como su 3er parámetro.

Ejemplo

#include <algorithm>
#include <iostream>
#include <iterator>
#include <random>
#include <vector>

int main()
{
    std::vector<int> v{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    
    std::random_device rd;
    std::mt19937 g(rd());
    
    std::shuffle(v.begin(), v.end(), g);
    
    std::copy(v.begin(), v.end(), std::ostream_iterator<int>(std::cout, " "));
    std::cout << '\n';
}

8 6 10 4 2 3 7 1 9 5

Informes de defectos

Los siguientes informes de defectos que cambian el comportamiento se aplicaron retroactivamente a los estándares C++ previamente publicados.

Véase también