可扩展的随机和完整迭代？

Question

假设我有一个列表列表，如下所示：

• [[a, b, c, d, e],
• [f, g, h],
• [i, j, k, l]]

所以外部列表的大小为 3，内部列表的大小为 5、3 和 4。

我需要从任何这些内部列表中获取一个随机元素，假设每个元素都有同样随机的机会。所以我可以写一个算法：

• 在0和totalListsSize (5 + 3 + 4) = 12之间生成一个随机数，例如randomIndex 7
• 遍历所有列表并减去它们的大小，如果它大于它们的大小，例如randomIndex 7 - firstListSize 5 = newRandomIndex 2
• 返回下一个列表中的元素randomIndex 2 in secondList = element g。

问题是顺序选择必须是完整且可耗尽的：在上面示例中的 12 次顺序选择之后，我必须选择每个元素一次。

有没有一种可扩展的方法？

• 不首先初始化所有列表并随机化加入的列表
• 如果持有已选择索引的布尔数组，则无需遍历该布尔数组来转换生成的randomIndex。

Answer 1

您为什么不生成所有可能索引的排列（换句话说，您将序列 [0,12) 打乱）。然后你就知道你会以随机顺序准确地击中所有元素。

为了高效查找，您可以保留数组长度的总和。在您的示例中：0、5、8、12。这样您就可以进行二进制搜索以通过“总索引”查找任何数组。

Answer 2

好吧，您可以创建一组可能的索引，随机选择其中一个，删除选定的索引并访问相应的对象。

或者，正如您所说，您可以创建一个连接列表并从中选择，删除任何选定的元素。

这两种方法都需要一些初始化，但无论如何你都必须做一些簿记。

另一种方法可能是将选定的索引存储在一个集合中，然后在创建一个新的随机索引后，您可以检查新索引是否已经在“已使用”集合中。但是，如果您想选择整个池的高百分比，这种方法会变得越来越慢，因为您会更频繁地获得已使用的索引。如果只从大列表中选择几个，这种方法可能会更好，因为它不需要太多的初始化和内存。

Answer 3

是否可以在“弹出”它们时从列表中删除元素？

如果是这样，您可以简单地这样做：只需在选择时从列表中删除一个元素，然后在计算下一个索引之前从总大小中减去一个，并根据需要重复。

Answer 4

我建议如下：

• 存储整数列表mark，它会记住每个列表中的选定元素

• 然后，确定哪个元素对应于您的randomIndex：

  List<List<Integer>> mark    = // ... one mark list for each array
  E[][] lists = // ... the lists you want to select random elements from
  
  void selectAllElementsOnce( int totalElementCount ){
      Random r = new Random();
      for(int selected = 0; selected < totalElementCount; selected++){
          E element = this.elementForRandomIndex(r.nextInt(totalElementCount - selected));
          // do something with this element
      }
  }
  
  E elementForRandomIndex( int randomIndex ) {
      for(int i = 0; i < lists.length; i++ ) {
          if(randomIndex < lists[i].length - mark.get( i ).size()) {
              int j = 0;
              while(mark.get( i ).size() > j && mark.get( i ).get( j ) <= randomIndex) {
                  randomIndex++ ;
                  j++ ;
              }
              mark.get( i ).add( j, randomIndex );
              return lists[i][randomIndex];
          } else {
              randomIndex -= lists[i].length - mark.get( i ).size();
          }
      }
      throw new IndexOutOfBoundsException();
  }
  

该解决方案的复杂性在于 O(numberOfLists + maximumListSize) 的实现，用于实现在恒定时间内提供元素访问的标记列表（例如 ArrayList）。请注意，它不是两个术语的乘积，因为只迭代了一个列表。

Answer 5

使用以下类：

import java.util.Enumeration;
import java.util.Random;

public class RandomPermuteIterator implements Enumeration<Long> {
    int c = 1013904223, a = 1664525;
    long seed, N, m, next;
    boolean hasNext = true;

    public RandomPermuteIterator(long N) throws Exception {
        if (N <= 0 || N > Math.pow(2, 62)) throw new Exception("Unsupported size: " + N);
        this.N = N;
        m = (long) Math.pow(2, Math.ceil(Math.log(N) / Math.log(2)));
        next = seed = new Random().nextInt((int) Math.min(N, Integer.MAX_VALUE));
    }

    public static void main(String[] args) throws Exception {
        RandomPermuteIterator r = new RandomPermuteIterator(100);
        while (r.hasMoreElements()) System.out.print(r.nextElement() + " ");
    }

    @Override
    public boolean hasMoreElements() {
        return hasNext;
    }

    @Override
    public Long nextElement() {
        next = (a * next + c) % m;
        while (next >= N) next = (a * next + c) % m;
        if (next == seed) hasNext = false;
        return  next;
    }
}