随机数生成方法及序列随机排序

srand()以及rand()函数：

void srand(unsigned int seed);// 初始化随机数发生器，用于给rand()函数设定种子
int rand(void);//用于产生一个伪随机unsigned int 整数

        srand()就是给rand()提供种子seed。如果srand每次输入的数值是一样的，那么每次运行产生的随机数也是一样的，也就是说，以一个固定的数值作为种子是一个缺点。 通常的做法是以这样一句代码srand((unsigned)time(NULL));或srand(GetCurrentTime());来取代，这样将使得种子为一个不固定的数， 这样产生的随机数就不会每次执行都一样了。所以，srand 和 rand 应该组和使用。一般来说，srand 是对 rand 进行设置。 
比如： 

srand((UINT)GetCurrentTime()); 
int x = rand() % 100; 

是生成 0 到 100 之间的随机数。

这里要提醒大家一下，如果用"int x = rand() % 100;"来生成 0 到 100 之间的随机数这种方法是不或取的， 比较好的做法是：

j=(int)(n*rand()/(RAND_MAX+1.0));// 产生一个0到n之间的随机

那么问题来了: C的函数库之所以没有把使用系统时钟初始化随机种子这步重要的操作直接放进rand函数的实现中，我觉得至少有三个原因： 
（1）可以高效产生连续的随机数，不用每次都初始化； 
（2）给程序员以更高的灵活性，因为可能在要求较高的场合，应该使用更好的的数据做种子，而不是系统时钟； 
（3）对于只是想产生大量伪随机数来尽兴某种验证或者统计，未必需要初始化，大不了程序每次运行都产生同样的一系列随机数而已——有些情况下，这是无所谓的。
事实上有一个更重要的原因： 
作为伪随机序列产生器的rand()函数，必须具备的一个重要特性就是--产生的序列必须是可重现的。 这不仅仅是一个算法，相当大的程度上，它关系到代码测试的准确性。如果算法中使用了和rand()的结果相关的数据，通过一个可控的可重现序列，我们就有机会再现每一次测试的过程，从而更有效的找到问题的所在。 所以这里提出一个建议，代码中，如果rand()的函数结果关系到算法的结果，那么，必须保证你的rand()调用是可重现的。


random_shuffle()函数：
        STL中的函数random_shuffle()用来对一个元素序列进行重新排序（随机的），包含在头文件 algorithm.h 中。
函数原型如下：

template<class RandomAccessIterator>
   void random_shuffle(
      RandomAccessIterator _First, //指向序列首元素的迭代器
      RandomAccessIterator _Last  //指向序列最后一个元素的下一个位置的迭代器
   );
template<class RandomAccessIterator, class RandomNumberGenerator>
   void random_shuffle(
      RandomAccessIterator _First,
      RandomAccessIterator _Last,
      RandomNumberGenerator& _Rand //调用随机数产生器的函数
   );

random_shuffle()是一个完全通用的算法，适用于内置数据类型和用户自定义类型。同时，由于STL算法不仅适用于容器，也适用于序列，因此，random_shuffle()算法可用于内置数组。
其实例代码如下：

#include <iostream>
#include <vector>
#include <algorithm>
#include <string>

int main()
{
    int i;
    //用于内置数据类型
    std::vector<int> vi;
    for(i=0; i<100; i++)
    {
        vi.push_back(i);        
    }
    std::random_shuffle(vi.begin(), vi.end());
    std::vector<int>::iterator it;
    for(it=vi.begin(); it!=vi.end(); it++)
    {
        std::cout<<*it<<std::endl;                  
    }
    //用于用户自定义类型
    std::vector<std::string> vs;
    vs.push_back(std::string("Sunday"));
    vs.push_back(std::string("Monday"));
    vs.push_back(std::string("Tuesday"));
    vs.push_back(std::string("Wednesday"));
    vs.push_back(std::string("Thursday"));
    vs.push_back(std::string("Friday"));
    vs.push_back(std::string("Saturday"));
    std::random_shuffle(vs.begin(), vs.end());
    for(i=0; i<7; i++)
    {
        std::cout<<vs[i]<<std::endl;       
    }
    //用于数组
    char arr[6] = {'a', 'b', 'c', 'd', 'e', 'f'};
    std::random_shuffle(arr, arr+6);
    for(i=0; i<6; i++)
    {
        std::cout<<arr[i]<<" ";       
    }
    std::cout<<std::endl;
    system("pause");
    return 0;
}

细心的同学可能发现了，每次我们重新运行程序时，虽然序列的顺序是改变了， 但random_shuffle每次产生的随机顺序都一样的，这是为什么呢？

原理很简单，随机数是通过一个算法产生的，当它的初始种子确定后，后面的序列是一定的。要让它变化，只能通过srand重设种子，同时种子要与时间相关，这样就达到随机了。即：

在使用random_shuffle()之前，需要调调srand(GetCurrentTime())设置种子。

其实我们应该注意到random_shuffle另一种方式的第三个参数我们还没有使用，其实它也是用来设置随机种子的函数，我从一篇博文中学习了如何使用它，链接在此，我先贴一点代码一起学习吧：

#include <iostream>  
#include <algorithm>  
#include <vector>  
#include <ctime>  
#include <cstdlib>  
  
using namespace std;  
  
const int POKER_NUM = 52; //52张扑克牌  
  
void print_poker(int PokerNum)  
{  
    cout << PokerNum << " ";  
}  

class MyRand  
{      
public:  
    int operator()(int index)  
    {  
        return rand() % POKER_NUM;  
    }  
};  

void main()  
{  
    srand( (unsigned)time(NULL) ); //设置随即数生成器的种子  
	
    vector<int> poker; //一副牌,牌点数从 1 计  
	
    //初始化  
    for (int num = 0; num < POKER_NUM; ++num)  
    {  
        poker.push_back(num+1);  
    }  
	
    //用默认随机数洗一遍  
    random_shuffle(poker.begin(), poker.end());  
    for_each(poker.begin(), poker.end(), print_poker);  
    cout << endl;  
	
    //用自定义随机数再洗一遍  
    random_shuffle(poker.begin(), poker.end(), MyRand());  
    copy(poker.begin(), poker.end(), ostream_iterator<int>(cout, " "));  
    cout << endl;      
}