媒介
终究能够最先 Collection Functions 部份了。
能够有的童鞋是第一次看楼主的系列文章，这里再做下简朴的引见。楼主在浏览 underscore.js 源码的时刻，学到了许多，同时以为有些知识点能够自力出来，写成文章与人人分享，而本文恰是其中之一（完整的系列请猛戳 https://github.com/hanzichi/underscore-analysis）。之前楼主已和人人分享了 Object 和 Array 的扩大要领中一些有意思的知识点，本日最先解读 Collection 部份。
看完 Collection Functions 部份的源码，起首如饥似渴想跟人人分享的恰是本文主题 —— 数组乱序。这是一道典范的前端口试题，给你一个数组，将其打乱，返回新的数组，即为数组乱序，也称为洗牌题目。
一个好的计划须要具有两个前提，一是准确性，毋庸置疑，这是必需的，二是高效性，在确保准确的前提下，怎样将复杂度降到最小，是我们须要思索的。
splice
几年前楼主还真碰到过洗牌题目，还真的是 “洗牌”。当时是用 cocos2d-js（当时还叫 cocos2d-html5）做牌类游戏，发牌前毫无疑问须要洗牌。
当时我是如许做的。每次 random 一个下标，看看这个元素有无被选过，假如被选过了，继承 random，假如没有，将其标记，然后存入返回数组，直到一切元素都被标记了。厥后经同事指点，每次选中后，能够直接从数组中删除，无需标记了，因而获得下面的代码。
function shuffle(a) {
var b = [];
while (a.length) {
var index = ~~(Math.random() * a.length);
b.push(a[index]);
a.splice(index, 1);
}
return b;
}这个解法的准确性应当是没有题目的（有兴致的能够本身去证实下）。我们假定数组的元素为 0 – 10，对其乱序 N 次，那末每一个位置上的效果加起来的均匀值理论上应当靠近 (0 + 10) / 2 = 5，且 N 越大，越靠近 5。为了能有个直观的视觉感觉，我们假定乱序 1w 次，而且将效果做成了图表，猛戳 http://hanzichi.github.io/test-case/shuffle/splice/ 检察，效果照样很乐观的。
考证了准确性，还要体贴一下它的复杂度。由于顺序中用了 splice，假如把 splice 的复杂度看成是 O(n)，那末全部顺序的复杂度是 O(n^2)。
Math.random()
另一个为人津津有味的要领是 “奇妙运用” JavaScript 中的 Math.random() 函数。
function shuffle(a) {
return a.concat().sort(function(a, b) {
return Math.random() - 0.5;
});
}一样是 [0, 1, 2 … 10] 作为初始值，一样跑了 1w 组 case，效果请猛戳 http://hanzichi.github.io/test-case/shuffle/Math.random/。
看均匀值的图表，很显著能够看到曲线浮动，而且屡次革新，折现的大抵走向一致，均匀值更是在 5 高低 0.4 的区间浮动。假如我们将 [0, 1, 2 .. 9] 作为初始数组，能够看到越发显著不符预期的效果（有兴致的能够本身去试下）。究其原因，要追查 JavaScript 引擎关于 Math.random() 的完成道理，这里就不展开了（实际上是我也不知道）。由于 ECMAScript 并没有划定 JavaScript 引擎关于 Math.random() 应当完成的体式格局，所以我猜测差别浏览器经由如许的乱序后，效果也不一样。
什么时刻能够用这类要领乱序呢？”非正式” 场所，一些手写 DEMO 须要乱序的场所，这不失为一种 clever solution。
然则这类解法不只不准确，而且 sort 的复杂度，均匀下来应当是 O(nlogn)，跟我们接下来要说的正解照样有不少差异的。
Fisher–Yates Shuffle
关于数组乱序，准确的解法应当是 Fisher–Yates Shuffle，复杂度 O(n)。
实在它的头脑异常的简朴，遍历数组元素，将其与之前的恣意元素交流。由于遍历有夙昔向后和从后往前两种体式格局，所以该算法大抵也有两个版本的完成。
从后往前的版本：
function shuffle(array) {
var _array = array.concat();
for (var i = _array.length; i--; ) {
var j = Math.floor(Math.random() * (i + 1));
var temp = _array[i];
_array[i] = _array[j];
_array[j] = temp;
}
return _array;
}underscore 中采纳夙昔今后遍历元素的体式格局，完成以下：
// Shuffle a collection, using the modern version of the
// [Fisher-Yates shuffle](http://en.wikipedia.org/wiki/Fisher–Yates_shuffle).
_.shuffle = function(obj) {
var set = isArrayLike(obj) ? obj : _.values(obj);
var length = set.length;
var shuffled = Array(length);
for (var index = 0, rand; index < length; index++) {
rand = _.random(0, index);
if (rand !== index) shuffled[index] = shuffled[rand];
shuffled[rand] = set[index];
}
return shuffled;
};将其解耦分离出来，以下：
function shuffle(a) {
var length = a.length;
var shuffled = Array(length);
for (var index = 0, rand; index < length; index++) {
rand = ~~(Math.random() * (index + 1));
if (rand !== index)
shuffled[index] = shuffled[rand];
shuffled[rand] = a[index];
}
return shuffled;
}跟前面一样，做了下数据图表，猛戳 http://hanzichi.github.io/test-case/shuffle/Fisher-Yates/。
关于证实，援用自月影先生的文章：
随机性的数学归纳法证实
对 n 个数举行随机：
起首我们斟酌 n = 2 的状况，依据算法，显然有 1/2 的几率两个数交流，有 1/2 的几率两个数不交流，因而对 n = 2 的状况，元素出如今每一个位置的几率都是 1/2，满足随机性要求。
假定有 i 个数， i >= 2 时，算法随机性符合要求，即每一个数出如今 i 个位置上每一个位置的几率都是 1/i。
关于 i + 1 个数，根据我们的算法，在第一次轮回时，每一个数都有 1/(i+1) 的几率被交流到最末端，所以每一个元素出如今最末一名的几率都是 1/(i+1) 。而每一个数也都有 i/(i+1) 的几率不被交流到最末端，假如不被交流，从第二次轮回最先还原成 i 个数随机，依据 2. 的假定，它们出如今 i 个位置的几率是 1/i。因而每一个数出如今前 i 位恣意一名的几率是 (i/(i+1)) * (1/i) = 1/(i+1)，也是 1/(i+1)。
综合 1. 2. 3. 得出，关于恣意 n >= 2，经由这个算法，每一个元素出如今 n 个位置恣意一个位置的几率都是 1/n。
小结
关于数组乱序，假如口试中被问到，能说出 “Fisher–Yates Shuffle”，而且能基础说出道理（你也看到了，实在代码异常的简朴），那末基础应当没有题目了；假如能更进一步，将其证实呈上（以至一些口试官都能够一时证实不了），那末就牛逼了。万万不能只会用 Math.random() 投机倒把！
Read More：
