我遇到了以下洗牌算法的分析：
Q：给定一个不同整数的数组，给一个算法随机 重新排序整数，以便每个可能的重新排序都是平等的 可能。换句话说，给定一副牌，你怎么能洗牌？ 它们使得卡片的任何排列都有同样的可能性？
好答案：按顺序浏览元素，将每个元素与 数组中不早于 元素。这需要 O(n) 时间。注意有几种可能 这个问题的解决方案，以及几个好看的答案 这是不正确的。比如对上面的稍作修改 算法，其中一个切换每个元素与任何元素 数组不会以相同的概率进行每次重新排序。
我想知道为什么将每个元素与数组中的任何其他元素切换不会产生良好的随机播放，而不是使用 Knuth 随机播放（已描述）。另外，Knuth 如何以相等的概率随机选择值？非常感谢任何数学或证明。
【问题讨论】：
标签： algorithm
该算法不产生均匀随机排列的最简单证明
for (int i = 0; i < 3; ++i) {
swap(a[i], a[rand() % 3]);
}
是不是它产生了 27 种可能的结果，但只有 3 种！ = 6 个排列。由于 6 不除 27，所以一定有一些排列是采得太多，有些是采得少。
为什么 O(n) 算法是最优的？好吧，随机洗牌有时必须触及每个输入（以更改它们），因此任何最佳算法都需要至少完成 O(n) 的工作。
为什么 Knuth 算法是正确的？这需要更多的洞察力。您可以通过归纳证明以正确的概率选择第一个项目（每个项目同样可能是第一个），然后证明当您通过循环前进时，归纳步骤成立，第二个，第三个等项目是也以正确的概率从数组的其余部分中选择。
【讨论】：
swap(a[i], a[rand() % 3]);?
考虑一个三元素列表。它有这些可能的状态和相关的概率：
1 [a, b, c] (0)
在第一次洗牌操作中，a 有 1/3 的机会与任何元素交换，因此可能的状态和相关概率如下：
From (0)
1/3 [a, b, c] (1)
1/3 [b, a, c] (2)
1/3 [c, b, a] (3)
在第二次洗牌操作中，除了第二个槽外，同样的事情再次发生，所以：
From (1) ([a, b, c])
1/9 [b, a, c] (4)
1/9 [a, b, c] (5)
1/9 [a, c, b] (6)
From (2) ([b, a, c])
1/9 [a, b, c] (7)
1/9 [b, a, c] (8)
1/9 [b, c, a] (9)
From (3) ([c, b, a])
1/9 [b, c, a] (10)
1/9 [c, b, a] (11)
1/9 [c, a, b] (12)
在第三次洗牌操作中，同样的事情发生了，除了第三个槽，所以：
From (4) ([b, a, c])
1/27 [c, a, b] (13)
1/27 [b, c, a] (14)
1/27 [b, a, c] (15)
From (5) ([a, b, c])
1/27 [c, b, a] (16)
1/27 [a, c, b] (17)
1/27 [a, b, c] (18)
From (6) ([a, c, b])
1/27 [b, c, a] (19)
1/27 [a, b, c] (20)
1/27 [a, c, b] (21)
From (7) ([a, b, c])
1/27 [c, b, a] (22)
1/27 [a, c, b] (23)
1/27 [a, b, c] (24)
From (8) ([b, a, c])
1/27 [c, a, b] (25)
1/27 [b, c, a] (26)
1/27 [b, a, c] (27)
From (9) ([b, c, a])
1/27 [a, c, b] (28)
1/27 [b, a, c] (29)
1/27 [b, c, a] (30)
From (10) ([b, c, a])
1/27 [a, c, b] (31)
1/27 [b, a, c] (32)
1/27 [b, c, a] (33)
From (11) ([c, b, a])
1/27 [a, b, c] (34)
1/27 [c, a, b] (35)
1/27 [c, b, a] (36)
From (12) ([c, a, b])
1/27 [b, a, c] (37)
1/27 [c, b, a] (38)
1/27 [c, a, b] (39)
结合相似的术语，我们得到：
4/27 [a, b, c] From (18), (20), (24), (34)
5/27 [a, c, b] From (17), (21), (23), (28), (31)
5/27 [b, a, c] From (15), (27), (29), (32), (37)
5/27 [b, c, a] From (14), (19), (26), (30), (33)
4/27 [c, a, b] From (13), (25), (35), (39)
4/27 [c, b, a] From (16), (22), (36), (38)
这显然是不平衡的。
仅从尚未选择的元素中选择的随机播放是正确的。为了证明，我提出这个：
假设您有一袋元素。如果您从该袋子中随机挑选并将结果元素放入列表中，您将获得一个随机排序的列表。这本质上就是仅与尚未选择的那些元素进行交换（考虑将放置东西的列表作为列表的开头，将袋子作为可以交换的列表的尾部）。
【讨论】：
首先，所描述的算法为 O(n) 并不是完全，尽管它非常接近。实际上应该是 O(n*log(n))。
原因如下：第一次交换需要从 n 个元素中提取，然后是 n-1 ... 2。但是从 n 个元素中选择的复杂度应该是 log(n)，因为你必须随机生成 log(n)位。
rrenaud 给出了一个很好的论点，即“坏”算法不是统一的，所以我会尝试论证“好”算法是统一的。每一步你从 n, n-1, ... 1 个选项中选择一个，所以最终总共有 n 个！你可以做出的选择。既然有n！排列列表的方法，如果每个排列都可以通过至少一个选择序列到达，那么每个排列都可以通过一个选择序列到达。因此，为了证明它是一致的，我们只需要证明给定一些可能的排序，我们可以通过一系列选择来达到它。
现在问题看起来很简单。假设你从
a b c d e
你想得到
b c d e a
将光标放在第 0 个元素上。你应该换哪个？ b，因为你想把它移到0位置。现在进展。在每一步，你“身后”的所有元素都在正确的位置，所以当你走到尽头时，所有的元素都在正确的位置。
【讨论】：
rand() 的某些实现具有 32K 的 RAND_MAX。 （16 位。）因此，如果您想在 2^16 和 2^32 个项目之间随机播放，则需要 2 次调用 rand，并且随着数量的增长逐渐增加。 （如果您需要确保结果由于 mod 剪辑而真正无偏见，那就更棘手了：（但您可能很乐意忽略这种偏见。）
首先，请注意 Knuth 的方式必须是一致随机的，因为这本质上等同于从堆栈 A 中随机抽取卡片并通过以随机顺序放置这些卡片来形成堆栈 B。这必须是均匀随机的。
要看出另一种方式不好，只需表明不同结果的数量会排除一致的结果。有 52^52 种方法可以选择 1 到 52 之间的 52 个随机整数。但是，有 52 个！这些整数的排列。 52！有 47 作为一个因素，而 52^52 没有；所以52！不均分 52^52。这意味着至少一个排列比其他排列具有更多导致它的结果……要看到这一点，请尝试将结果均分，直到用完为止。由于结果的数量不是排列数量的倍数，因此您不能给每个人相同的数量。换句话说，如果你把所有的吸盘都给了，你不能把 12 个吸盘平均分配给 5 个孩子。原理相同。
【讨论】：