编程常用算法分析——洗牌算法

首先我们需要明白几个数学思想——————————————

一、 我们的洗牌算法是伪随机事件的一种。而随机事件我们也要明白几个概念

  随机数的特性：

随机性：不存在统计学偏差，是完全杂乱的数列

不可预测性：不能从过去的数列推测出下一个出现的数

不可重现性：除非将数列本身保存下来，否则不能重现相同的数列

 

随机数分为真随机数和伪随机数，我们程序使用的基本都是伪随机数，其中伪随机又分为强伪随机数和弱伪随机数。

• 真随机数，通过物理实验得出，比如掷钱币、骰子、转轮、使用电子元件的噪音、核裂变等。需要满足随机性、不可预测性、不可重现性。

• 伪随机数，通过一定算法和种子得出。软件实现的是伪随机数。

  • 强伪随机数，难以预测的随机数。需要满足随机性和不可预测性。

  • 弱伪随机数，易于预测的随机数。需要满足随机性

结合一下编程：Java中的随机数生成器

Java语言提供了几种随机数生成器，如前面提到的Random类，还有SecureRandom类。

伪随机数生成器

伪随机数发生器采用特定的算法，将随机数种子seed转换成一系列的伪随机数。伪随机数依赖于seed的值，给定相同的seed值总是生成相同的随机数。伪随机数的生成过程只依赖CPU，不依赖任何外部设备，生成速度快，不会阻塞。

Java提供的伪随机数发生器有java.util.Random类和java.util.concurrent.ThreadLocalRandom类。

Random类采用AtomicLong实现，保证多线程的线程安全性，但正如该类注释上说明的，多线程并发获取随机数时性能较差。

多线程环境中可以使用ThreadLocalRandom作为随机数发生器，ThreadLocalRandom采用了线程局部变量来改善性能，这样就可以使用long而不是AtomicLong，此外，ThreadLocalRandom还进行了字节填充，以避免伪共享。

强随机数发生器

强随机数发生器依赖于操作系统底层提供的随机事件。强随机数生成器的初始化速度和生成速度都较慢，而且由于需要一定的熵累积才能生成足够强度的随机数，所以可能会造成阻塞。熵累积通常来源于多个随机事件源，如敲击键盘的时间间隔，移动鼠标的距离与间隔，特定中断的时间间隔等。所以，只有在需要生成加密性强的随机数据的时候才用它。

Java提供的强随机数发生器是java.security.SecureRandom类，该类也是一个线程安全类，使用synchronize方法保证线程安全，但jdk并没有做出承诺在将来改变SecureRandom的线程安全性。因此，同Random一样，在高并发的多线程环境中可能会有性能问题。

在linux的实现中，可以使用/dev/random和/dev/urandom作为随机事件源。由于/dev/random是堵塞的，在读取随机数的时候，当熵池值为空的时候会堵塞影响性能，尤其是系统大并发的生成随机数的时候。

真随机数发生器

在Linux系统中，SecureRandom的实现借助了/dev/random和/dev/urandom，可以使用硬件噪音生成随机数；

http://random.org/，从1998年开始提供在线真随机数服务了，它用大气噪音生成真随机数。他也提供了Java工具类，可以拿来使用。地址：https://sourceforge.net/projects/randomjapi/

 

现在我们一起来讨论一下关于shuffle

时间复杂度：时间复杂度简单的理解就是执行语句的条数。如果有循环和递归，则忽略简单语句，直接算循环和递归的语句执行次数

时间复杂度为l

int n = 8, count = 0;;  
for(int i=1; i<=n; i *= 2) {  
    count++;  
} 

空间复杂度：空间复杂度也很简单的理解为临时变量占用的存储空间.

第一个算法：

随机抽出一张牌，检查这种牌是否被抽取过，如果已经被抽取过，则重新抽取，知道找到没有被抽取的牌；重复该过程，知道所有的牌都被抽取到。

这种算法是比较符合大脑的直观思维，这种算法有两种形式：

1. 每次随机抽取后，将抽取的牌拿出来，则此时剩余的牌为(N-1)，这种算法避免了重复抽取，但是每次抽取一张牌后，都有一个删除操作，需要在原始数组中删除随机选中的牌(可使用Hashtable实现)

function Shuffle (){
	let Arr = [];
     for(var i = 1; i <=52; i++){
        Arr.push(i)
    }
	var newArr = [];
	for (var i = 1; i <=52; i++) {
   		var random = Math.floor((Math.random()*Arr.length-1+1));
   		console.log(random)
   		newArr.push(Arr[random]);
   		Arr.splice(random,1);
	}
    console.log(newArr)
}
Shuffle ();

2. 每次随机抽取后，将抽取的符合要求的牌做好标记，但并不删除；与1相比，省去了删除的操作，但增加了而外的存储标志为的空间，同时导致可每次可能会抽取之前抽过的牌

这种方法的时间/空间复杂度都不好。

function Shuffle (){
    let Arr = [];
     for(var i = 1; i <=52; i++){
        Arr.push(i)
    }
    var newArr = [];
    for (var i = 1; i <=52; i++) {
           var random = Math.floor((Math.random()*Arr.length-1+1));
           console.log(random)
           newArr.push(Arr[random]);
           Arr.splice(random,1);
    }
    console.log(newArr)
}
Shuffle ();

第二个算法：

每次随机抽出两张牌交换，交换一定次数后结束：

void shuffle(int* array, int len){  
  const int suff_time = len;	    
  for (int idx = 0; i < suff_time; i++)	{	
  int i = rand() % len;		
  int j = rand() % len;				
  int temp = array[i];		
  array[i] = array[j];		array[j] = temp;	
}}

3、该算法每次随机选取一个数，然后将该数与数组中最后(或最前)的元素相交换(如果随机选中的是最后/最前的元素，则相当于没有发生交换)；然后缩小选取数组的范围，去掉最后的元素,即之前随机抽取出的数。重复上面的过程，直到剩余数组的大小为1，即只有一个元素时结束

void shuffle(int* array, int len)

{

    int i = len;

    int j = 0;

    int temp= = 0;

    if (i == 0)

{

return;

}

 

while (--i)

{

j = rand() % (i+1);

temp = array[i];

array[i] = array[j];

array[j] = temp

 犯过一个相当严重的错误：错误地把Floyd算法的i, j, k三层循环的位置顺序搞颠倒了。直到准备省选时我才突然意识到，Floyd算法应该最先枚举用于松驰操作的那个“中间变量”k，表示只经过从1到k的顶点的最短路；而我却一直习惯性地以为i, j, k应该顺次枚举。令人惊讶的是，这个错误跟了我那么久我居然从来都没有注意到过。后来，我发现有我这种经历的人不止一个。惯性思维很可能会让你接受一些明显错误的算法，并且让你用得坦坦荡荡，一辈子也发觉不了。
    假使你需要把一个数组随机打乱顺序进行重排。你需要保证重排后的结果是概率均等、完全随机的。下面两种算法哪一种是正确的？其中，random(a,b)函数用于返回一个从a到b（包括a和b）的随机整数。

1. for i:=1 to n do swap(a[i], a[random(1,n)]);
2. for i:=1 to n do swap(a[i], a[random(i,n)]);

    如果不仔细思考的话，绝大多数人会认为第一个算法才是真正随机的，因为它的操作“更对称”，保证了概率均等。但静下心来仔细思考，你会发现第二种算法才是真正满足随机性的。为了证明这一点，只需要注意到算法的本质是“随机确定a[1]的值，然后递归地对后n-1位进行操作”，用数学归纳法即可轻易说明算法的正确性。而事实上，这段程序一共将会产生n*(n-1)*(n-2)*…*1种等可能的情况，它们正好与1至n的n!种排列一一对应。
     有人会问，那第一种算法为什么就错了呢？看它的样子多么对称美观啊……且慢，我还没说第一种算法是错的哦！虽然第一种算法将产生比第二种算法更多的可能性，会导致一些重复的数列，但完全有可能每种数列重复了相同的次数，概率仍然是均等的。事实上，更有可能发生的是，这两种算法都是正确的，不过相比之下呢第一种算法显得更加对称美观一些。为此，我们需要说明，第一种算法产生的所有情况均等地分成了n!个等价的结果。显然，这个算法将会产生n^n种情况，而我们的排列一共有n!个，因此n^n必须能够被n!整除才行（否则就不能均等地分布了）。但是，n!里含有所有不超过n的质数，而n^n里却只有n的那几个质因子。这表明要想n^n能被n!整除，n的质因子中必须含有所有不超过n的质数。这个结论看上去相当荒唐，反例遍地都是，并且直觉上告诉我们对于所有大于2的n这都是不成立的。为了证明这一点，只需要注意到2是质数，并且根据Bertrand-Chebyshev定理，在n/2和n之间一定还有一个质数。这两个质数的乘积已经大于n了。搞了半天，第一种看似对称而美观的算法居然是错的！