Algorithm 洗牌列表，确保没有项目保持在相同的位置

我想洗牌一个独特的项目列表，但不是做一个完全随机洗牌。我需要确保洗牌列表中没有任何元素与原始列表中的位置相同。因此，如果原始列表是（A，B，C，D，E），这个结果是可以的：（C，D，B，E，A），但是这个结果不会：（C，E，A，D，B），因为“D”仍然是第四项。该列表最多包含七项。极端效率不是一个考虑因素。我认为对Fisher/Yates的这种修改确实起到了作用，但我无法从数学上证明：

function shuffle(data) {
    for (var i = 0; i < data.length - 1; i++) {
        var j = i + 1 + Math.floor(Math.random() * (data.length - i - 1));

        var temp = data[j];
        data[j] = data[i];
        data[i] = temp;
    }
}

函数洗牌（数据）{
对于（var i=0；i

您正在查找您的条目

首先，你的算法的工作原理是它输出一个随机的混乱，即没有固定点的排列。然而，它有一个巨大的缺陷（您可能不介意，但值得记住）：一些混乱无法通过您的算法获得。换句话说，它为一些可能的混乱提供了零概率，因此得到的分布肯定不是均匀随机的

如评论中所建议的，一种可能的解决方案是使用拒绝算法：

• 随机均匀地选择一个排列
• 如果它没有固定点，则返回它
• 否则重试

渐进地，获得精神错乱的概率接近

1/e

=0.3679（如维基百科文章所示）。这意味着要获得一个混乱，你需要生成一个平均值

e

=2.718的排列，这是相当昂贵的

更好的方法是在算法的每一步都拒绝。在伪代码中，类似这样的内容（假设原始数组在

i

位置包含

i

，即

a[i]==i

）：

与您的算法的主要区别在于，我们允许

j

等于

i

，但前提是它不产生固定点。它的执行时间稍长（由于拒绝部分），并且要求您能够检查条目是否在其原始位置，但它的优点是它可以产生所有可能的混乱（就此而言，是一致的）

我猜应该存在非拒绝算法，但我相信它们不那么直截了当

编辑：

我的算法实际上很糟糕：你仍然有机会以最后一点未缓冲结束，并且分布根本不是随机的，请参见模拟的边缘分布：

可以找到一种产生均匀分布的混乱的算法，并对问题进行一些上下文、透彻的解释和分析

第二次编辑：

实际上，您的算法被称为，并且以相等的概率生成所有循环。因此，任何不是一个循环而是几个不相交循环的乘积的混乱都不能用该算法得到。例如，对于四个元素，交换1和2，以及3和4的排列是一种混乱，但不是一个循环

如果您不介意只获取循环，那么Sattolo的算法就是一条可行之路，它实际上比任何统一的混乱算法都快得多，因为不需要拒绝。

在C++中：

template <class T> void shuffle(std::vector<T>&arr)
{
    int size = arr.size();

    for (auto i = 1; i < size; i++)
    {
        int n = rand() % (size - i) + i;
        std::swap(arr[i-1], arr[n]);
    }
}

template void shuffle（std:：vector&arr）
{
int size=arr.size（）；
用于（自动i=1；i

正如@FelixCQ所提到的，您正在寻找的洗牌被称为混乱。构造均匀随机分布的无序不是一个简单的问题，但是一些结果在文献中是已知的。构造混乱最明显的方法是拒绝方法：使用Fisher-Yates算法生成均匀随机分布的排列，然后拒绝具有固定点的排列。这个过程的平均运行时间是e*n+o（n），其中e是欧拉常数2.71828。。。这对你的情况可能有用

另一种产生混乱的主要方法是使用递归算法。然而，与Fisher-Yates不同，该算法有两个分支：列表中的最后一项可以与另一项交换（即，两个周期的一部分），或者可以是更大周期的一部分。因此，在每一步，递归算法都必须进行分支，以生成所有可能的混乱。此外，选择一个分支还是另一个分支的决定必须以正确的概率作出

设D（n）为n项的错乱数。在每个阶段，将最后一个项目分为两个周期的分支数为（n-1）D（n-2），将最后一个项目分为较大周期的分支数为（n-1）D（n-1）。这为我们提供了一种计算失调次数的递归方法，即D（n）=（n-1）（D（n-2）+D（n-1）），并为我们提供了在任何阶段分支到两个循环的概率，即（n-1）D（n-2）/D（n-1）

现在我们可以通过决定最后一个元素所属的循环类型，将最后一个元素交换到n-1个其他位置之一，然后重复来构建混乱。然而，跟踪所有分支可能很复杂，因此在2008年，一些研究人员利用这些想法开发了一种简化的算法。您可以在中看到演练。该算法的运行时间与2n+O（log^2n）成正比，与拒绝方法相比，速度提高了36%

我已经用Java实现了他们的算法。使用longs最多可用于22个左右的n。使用大整数将算法扩展到n=170左右。使用大整数和大小数将算法扩展到n=40000左右（限制取决于res中的内存使用）

template <class T> void shuffle(std::vector<T>&arr)
{
    int size = arr.size();

    for (auto i = 1; i < size; i++)
    {
        int n = rand() % (size - i) + i;
        std::swap(arr[i-1], arr[n]);
    }
}

    package io.github.edoolittle.combinatorics;

    import java.math.BigInteger;
    import java.math.BigDecimal;
    import java.math.MathContext;
    import java.util.Random;
    import java.util.HashMap;
    import java.util.TreeMap;

    public final class Derangements {

      // cache calculated values to speed up recursive algorithm
      private static HashMap<Integer,BigInteger> numberOfDerangementsMap 
        = new HashMap<Integer,BigInteger>();
      private static int greatestNCached = -1;

      // load numberOfDerangementsMap with initial values D(0)=1 and D(1)=0
      static {
        numberOfDerangementsMap.put(0,BigInteger.valueOf(1));
        numberOfDerangementsMap.put(1,BigInteger.valueOf(0));
        greatestNCached = 1;
      }

      private static Random rand = new Random();

      // private default constructor so class isn't accidentally instantiated
      private Derangements() { }

      public static BigInteger numberOfDerangements(int n)
        throws IllegalArgumentException {
        if (numberOfDerangementsMap.containsKey(n)) {
          return numberOfDerangementsMap.get(n);
        } else if (n>=2) {
          // pre-load the cache to avoid stack overflow (occurs near n=5000)
          for (int i=greatestNCached+1; i<n; i++) numberOfDerangements(i);
          greatestNCached = n-1;
          // recursion for derangements: D(n) = (n-1)*(D(n-1) + D(n-2))
          BigInteger Dn_1 = numberOfDerangements(n-1);
          BigInteger Dn_2 = numberOfDerangements(n-2);
          BigInteger Dn = (Dn_1.add(Dn_2)).multiply(BigInteger.valueOf(n-1));
          numberOfDerangementsMap.put(n,Dn);
          greatestNCached = n;
          return Dn;
        } else {
          throw new IllegalArgumentException("argument must be >= 0 but was " + n);
        }
      }

      public static int[] randomDerangement(int n)
        throws IllegalArgumentException {

        if (n<2)
          throw new IllegalArgumentException("argument must be >= 2 but was " + n);

        int[] result = new int[n];
        boolean[] mark = new boolean[n];

        for (int i=0; i<n; i++) {
          result[i] = i;
          mark[i] = false;
        }
        int unmarked = n;

        for (int i=n-1; i>=0; i--) {
          if (unmarked<2) break; // can't move anything else
          if (mark[i]) continue; // can't move item at i if marked

          // use the rejection method to generate random unmarked index j < i;
          // this could be replaced by more straightforward technique
          int j;
          while (mark[j=rand.nextInt(i)]);

          // swap two elements of the array
          int temp = result[i];
          result[i] = result[j];
          result[j] = temp;

          // mark position j as end of cycle with probability (u-1)D(u-2)/D(u)
          double probability 
        = (new BigDecimal(numberOfDerangements(unmarked-2))).
        multiply(new BigDecimal(unmarked-1)).
        divide(new BigDecimal(numberOfDerangements(unmarked)),
               MathContext.DECIMAL64).doubleValue();
          if (rand.nextDouble() < probability) {
        mark[j] = true;
        unmarked--;
          }

          // position i now becomes out of play so we could mark it
          //mark[i] = true;
          // but we don't need to because loop won't touch it from now on
          // however we do have to decrement unmarked
          unmarked--;
        }

        return result;
      }

      // unit tests
      public static void main(String[] args) {
        // test derangement numbers D(i)
        for (int i=0; i<100; i++) {
          System.out.println("D(" + i + ") = " + numberOfDerangements(i));
        }
        System.out.println();

        // test quantity (u-1)D_(u-2)/D_u for overflow, inaccuracy
        for (int u=2; u<100; u++) {
          double d = numberOfDerangements(u-2).doubleValue() * (u-1) /
        numberOfDerangements(u).doubleValue();
          System.out.println((u-1) + " * D(" + (u-2) + ") / D(" + u + ") = " + d);
        }

        System.out.println();

        // test derangements for correctness, uniform distribution
        int size = 5;
        long reps = 10000000;
        TreeMap<String,Integer> countMap = new TreeMap<String,Integer>();
        System.out.println("Derangement\tCount");
        System.out.println("-----------\t-----");
        for (long rep = 0; rep < reps; rep++) {
          int[] d = randomDerangement(size);
          String s = "";
          String sep = "";
          if (size > 10) sep = " ";
          for (int i=0; i<d.length; i++) {
        s += d[i] + sep;
          }

          if (countMap.containsKey(s)) {
        countMap.put(s,countMap.get(s)+1);
          } else {
        countMap.put(s,1);
          }
        }

        for (String key : countMap.keySet()) {
          System.out.println(key + "\t\t" + countMap.get(key));
        }

        System.out.println();

        // large random derangement
        int size1 = 1000;
        System.out.println("Random derangement of " + size1 + " elements:");
        int[] d1 = randomDerangement(size1);
        for (int i=0; i<d1.length; i++) {
          System.out.print(d1[i] + " ");
        }

        System.out.println();
        System.out.println();

        System.out.println("We start to run into memory issues around u=40000:");
        {
          // increase this number from 40000 to around 50000 to trigger
          // out of memory-type exceptions
          int u = 40003;
          BigDecimal d = (new BigDecimal(numberOfDerangements(u-2))).
        multiply(new BigDecimal(u-1)).
        divide(new BigDecimal(numberOfDerangements(u)),MathContext.DECIMAL64);
          System.out.println((u-1) + " * D(" + (u-2) + ") / D(" + u + ") = " + d);
        }

      }

    }