std::random_shuffle, std::shuffle

This page has been machine-translated from the English version of the wiki using Google Translate.

The translation may contain errors and awkward wording. Hover over text to see the original version. You can help to fix errors and improve the translation. For instructions click here.

Click here for the English version of this page

Definido en la cabecera `<algorithm>`
template< class RandomIt > void random_shuffle( RandomIt first, RandomIt last );	(1)
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 );	(2)	(hasta C++11) (desde C++11)
template< class RandomIt, class URNG > void shuffle( RandomIt first, RandomIt last, URNG&& g );	(3)	(desde C++11)

Reordena los elementos en el rango dado [first, last) tales que cada permutación posible de estos elementos tiene la misma probabilidad de aparición .

1)

El generador de números aleatorios es definido por la implementación, pero el std::rand función se utiliza a menudo .

2)

El generador de números aleatorios es el objeto de la función r .

3)

El generador de números aleatorios es el objeto de la función g .

[editar] Parámetros

first, last	-	la gama de elementos para barajar al azar Original: the range of elements to shuffle randomly The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.
r	-	objeto de función que devuelve un valor escogido de forma aleatoria del tipo convertible a `iterator_traits<RandomIt>::difference_type` en el intervalo [0, n) si se invoca como `r(n)` Original: function object returning a randomly chosen value of type convertible to `iterator_traits<RandomIt>::difference_type` in the interval [0,n) if invoked as `r(n)` The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.
g	-	objeto de función que devuelve un valor escogido de forma aleatoria de `URNG::result_type` tipo en el intervalo [g.min (), g.max ()] si invoca como `g()` (por ejemplo, cualquiera de los generadores de números aleatorios uniformes de `<random>`) Original: function object returning a randomly chosen value of type `URNG::result_type` in the interval [g.min(), g.max()] if invoked as `g()` (e.g. any of the uniform random number generators from `<random>`) The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.
Requerimientos de tipo
- `RandomIt` debe reunir los requerimientos de `ValueSwappable` y `RandomAccessIterator`.
- `URNG` debe reunir los requerimientos de `UniformRandomNumberGenerator`.

[editar] Valor de retorno

(Ninguno)

[editar] Complejidad

lineal en la distancia entre first y last

[editar] Posible implementación

Primera versión

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

Segunda versión

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

[editar] Ejemplo

El código siguiente cambia aleatoriamente los números enteros 1 .. 10:

#include <random>
#include <algorithm>
#include <iterator>
#include <iostream>
 
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);
 
    copy(v.begin(), v.end(), std::ostream_iterator<int>(std::cout, " "));
    std::cout << "\n";
}

Salida posible:

8 6 10 4 2 3 7 1 9 5

[editar] Ver también

next_permutation	generates the next greater lexicographic permutation of a range of elements (plantilla de función) [editar]
prev_permutation	generates the next smaller lexicographic permutation of a range of elements (plantilla de función) [editar]

Lenguaje
Cabeceras
Conceptos
Biblioteca de utilidades
Biblioteca de cadenas
Biblioteca de contenedores
Biblioteca de algoritmos
Biblioteca de iteradores
Biblioteca numérica
Biblioteca de entrada/salida
Biblioteca de localización
Biblioteca de expresiones regulares (C++11)
Biblioteca de operaciones atómicas (C++11)
Biblioteca de hilos/subprocesos (C++11)

cppreference.com

Buscar

Espacios de nombres

Variantes

Vistas

Acciones