【小当心得】证实洗牌算法随机性

本文对解释洗牌算法比较简略，主要在于证实其随机性

本文是学习洗牌算法的心得，表达不当或理解不对的地方，感谢您点评指正~

打乱一个数组

打乱一个没有重复元素的数组。

好比 const arr = [1, 2, 3, 4, 5], shuffle(arr) 后返回一个随机的数组。

随机的意思是数组上的每一个数字出如今每个位置的可能性都是随机的

Array.prototype.sort 作获得吗？代码以下

function shuffle(arr) {
   return arr.slice().sort(function(){ return Math.random() >= 0.5 ? -1 : 1;}); 
}
复制代码

因为浏览器内核各自实现不一样 Array.protype.sort 可能使用快排、归并，甚至冒泡等，因此没法保证其随机性

洗牌算法

上面咱们解释了随机的意思，数组上的每一个数字出如今每个位置的可能性都是随机的。有一种比较经常使用的算法，洗牌算法。（参阅 维基百科-洗牌算法）下面咱们使用 JavaScript 实现它

function shuffle() {
    const arr = this.nums.slice();
    let choice = arr.length; // 这个 choice 有两层含义
    while (choice > 0) {     // choice > 0 表示能够选择的个数大于 0
        let j = Math.floor(Math.random() * choice);  // 第一层含义：表示在多少个数（选择）里随机选一个，获取随机索引 [0, choice)
        choice--;   // choice-- 获得的是另外一个含义，也就是索引、所在位置；因为数组是以 0 做为下标，须要往左偏移，
        [arr[j], arr[choice]] = [arr[choice], arr[j]];  // 交换这两个数，完成了索引为 choice 的 arr[choice] 的随机
    }
    return arr;
}
复制代码

根据代码分析，while (choice > 0) {} 时间复杂度 O(n), 交换位置时间复杂度 O(1), 因此它的时间复杂度 T(n) = O(n); this.nums.slice(); 得出它的空间复杂是 O(n)

推导它超出我了个人认知范围，若是有小伙伴懂的，能够在留言区告诉我哈~

证实洗牌算法的随机性

咱们要证实的是

假设总共有 n 个数，其中数 a 出如今第 i 个位置的可能性，为 1/n。

这里的 i 是任意天然数、n 是任意正整数、a 是取自 n 的一个数。

根据上面的假设，假设是从后往前考虑，由于上面洗牌算法代码也是从后往前的

能够获得，数 a 不会出如今第 n-1 个位置，也不会出如今第 n-2 个位置，... 也不会出如今第 i+1 个位置，在 第 i 个位置出现了，数 a 只有一个，后面的状况，已经与 a 无关了。

上面提到的几种状况，第 n-1 个位置到第 i 个位置，它们对应着什么，关系又是什么？

咱们一步步地看

1. 数 a 不会出如今第 n-1 个位置，也就是从未被挑选的数（有 n 个）里，挑选不等于 a 的数（有 n-1 个），放在第 n-1 个位置，可能性 (n-1)/n，假设 b 被挑选出

   对应的是代码第一次循环

   let choice = n; // 表示在 n 个数（选择）里随机选一个
    while (choice > 0) {     // choice > 0 表示能够选择的个数大于 0
        let j = Math.floor(Math.random() * choice);  // 索引是随机的，arr[j] 恰好不等于 数 a ，可能性是 (n-1)/n ， 换一种说法就是 数 a 不在这个 choose-- 这个位置上
        choice--;   // 因为数组是以 0 做为下标，须要往左偏移
        [arr[j], arr[choice]] = [arr[choice], arr[j]];
    }
   复制代码

2. 数 a 也不会出如今第 n-2 个位置，同样的从未被挑选的数里，挑选不等于 a 的数，放在第 n-2 个位置，这里创建在第一步成立的条件下，由于 b 已经被挑选出了，未被挑选的数个数是 n-1 个， 不等于 a和b 的数（有 n-2 个）,因此这一步的可能性是 (n-1)/n * (n-2)/(n-1)

   对应的是代码第二次循环

   while (choice > 0) {     // choice > 0 表示能够选择的个数大于 0, 这里 choice = n-1
        let j = Math.floor(Math.random() * choice);  // 索引是随机的，arr[j] 恰好不等于 数 a ，可能性是 (n-2)/(n-1) ， 换一种说法就是 数 a 不在这个 choose-- 这个位置上
        choice--;   // 因为数组是以 0 做为下标，须要往左偏移
        [arr[j], arr[choice]] = [arr[choice], arr[j]];
    }
   复制代码

...(中间过程用...表示)

3. 最后一步，数 a 在 第 i 个位置出现了，从第 n-1 到第 i 个位置（包含 n-1 和 i），总共有 n-i 个位置，对应着 n-i 个数。能够获得，前面被挑选过的数，是 n-i-1 个（总共 n-i 个减去当前即将被挑选数 a）。总共有 n 个，减去前面被挑选过的数，获得未被挑选的个数是 n-(n-i-1) 即 i+1。恰好就是 a，只能是 a，单独这一步可能性就是 1/(i+1)

最后一步，是创建在前面的每一步的成立的基础，因此得出数 a 出如今第 i 个位置的可能性是

(n-1)/n * (n-2)/(n-1) * ... * 1/(i+1)

前一项的分子和后一项的分母两两消去，最后获得了 1/n。

即有 n 个数，其中数 a 出如今第 i 个位置的可能性，为 1/n。

洗牌算法随机性获得了证实。

参考资料

• wiki Fisher–Yates shuffle
• 掘金-打造属于本身的underscore系列（六）- 洗牌算法
• 博客园-三种洗牌算法shuffle

---

谢谢您的阅读。

您的鼓励和点赞，将成为我持续学习、写文章的动力