• // <algorithm> 
    // 由默认生成器生成(1)
    template <class RandomAccessIterator>
        void random_shuffle (
            RandomAccessIterator first,
            RandomAccessIterator last);
    // 由自写义生成器生成(2)
    template <class RandomAccessIterator,
        class RandomNumberGenerator>
        void random_shuffle (
            RandomAccessIterator first,
            RandomAccessIterator last,
            RandomNumberGenerator& gen);
  • // <algorithm> 
    // 由默认生成器生成(1)    
    template <class RandomAccessIterator>
        void random_shuffle (
            RandomAccessIterator first, 
            RandomAccessIterator last);
    // 由自写义生成器生成(2)
    template <class RandomAccessIterator,
    class RandomNumberGenerator>
        void random_shuffle (
            RandomAccessIterator first,
            RandomAccessIterator last,
            RandomNumberGenerator&& gen);
    

随机打乱指定范围中的元素的位置。

该函数等价于:

template<class _RanIt,
    class _Fn1,
    class _Diff> inline
    void _Random_shuffle(_RanIt _First, _RanIt _Last, _Fn1& _Func, _Diff *)
    {    // shuffle nonempty [_First, _Last) using random function _Func
        _RanIt _Next = _First;
        for (_Diff _Index = 2; ++_Next != _Last; ++_Index)
        {    // randomly swap element with self or earlier element
            _Diff _Off = _Func(_Index);
            _STD iter_swap(_Next, _First + _Off);
        }
    }
  • firstlast

    分别指向被打乱序列中初始及末尾位置的随机访问迭代器(Random-access Iterators)。这个范围即 [first,last) ,包括 first 到 last 间的所有元素,包括 first 指向的元素,但不包括 last 指向的元素。

    gen

    一元函数,接受一个参数并返回一个值。

    函数需返回一个非负值(Non-negative),且该值要小于它的参数。

    该函数不能修改其参数。

    可以是函数指针(Function pointer)类型或函数对象(Function object)类型。

  • 无。

  • 例 1

    #include <iostream>
    #include <algorithm>
    #include <iterator>
    #include <vector>
    #include <ctime>
    #include <cstdlib>
    
    #define CLASSFOO_VECTOR(type, name, ...) \
    static const type name##_a[] = __VA_ARGS__; \
    std::vector<type> name(name##_a, name##_a + sizeof(name##_a) / sizeof(*name##_a))
    
    namespace ClassFoo{
    
        int RandomRunc(int n) {
            return std::rand() % n;
        }
    
        struct _RandomStruct{
            int operator()(int n) {
                return std::rand() % n;
            }
        }RandomStruct;
    
        void RandomShuffle_1() {
            CLASSFOO_VECTOR(int, BigVector1, { 8, 23, 5, 7, 29, 0, 7, 7, 7, 1, 1 });
    
            // 使用默认随机化因子
            std::random_shuffle(
                std::begin(BigVector1),
                std::end(BigVector1));
            // 打印结果到流中
            std::copy(
                BigVector1.begin(),
                BigVector1.end(),
                std::ostream_iterator<int>(std::cout, " "));
            std::cout << std::endl;
    
            // 初始化随机数生成器
            std::srand(unsigned(std::time(0)));
    
            // 使用函数
            std::random_shuffle(
                std::begin(BigVector1),
                std::end(BigVector1),
                RandomRunc
                );
            // 打印结果到流中
            std::copy(
                BigVector1.begin(),
                BigVector1.end(),
                std::ostream_iterator<int>(std::cout, " "));
            std::cout << std::endl;
    
            // 使用函数对象
            std::random_shuffle(
                std::begin(BigVector1),
                std::end(BigVector1),
                RandomStruct
                );
            // 打印结果到流中
            std::copy(
                BigVector1.begin(),
                BigVector1.end(),
                std::ostream_iterator<int>(std::cout, " "));
            std::cout << std::endl;
        }
    }
    int main()
    {
        ClassFoo::RandomShuffle_1();
        return 0;
    }

    1 23 1 5 8 0 7 7 29 7 7
    7 0 7 5 8 7 1 23 1 29 7
    29 7 7 0 5 1 7 1 8 7 23 

  • 复杂度

    O(n)n 为 last first.

    数据争用相关

    范围 [first,last) 中的所有元素都被修改过。

    异常安全性相关

    如果随机数生成器、元素交换(Swap)或操作某个迭代器抛异常,该函数才会抛异常。

    注意 无效参数将导致未定义行为(Undefined behavior)