在 Python 中随机查找列表中可用位置的有效算法

Question

我需要随机将列表中的位置分配给输入。我需要先检查它是否没有被占用，然后再使用它。我能想到的最佳算法如下：

def get_random_addr(input_arr):

    while True:
        addr = random.randrange(1, len(input_arr))
        if input_arr[addr] is None:
            break
    return addr

这显然效率不高，因为当我们占用更多的槽时，循环需要更长的时间才能找到一个空槽，甚至可能需要很长时间（假设只剩下一个空槽）。你有更好的解决方案吗？

我是怎么做到的

根据选择的答案，这就是我最终这样做的方式。与搜索整个列表并找到None 元素并从检索到的集合中随机选择的解决方案相比，它非常快速和高效。我认为瓶颈是random.choice 方法，它似乎很慢。

# Create a list of indexes at the beginning when all the values are None 
available_index = list(range(1, len(input_arr)))
random.shuffle(available_index)

# To get a random index simply pop from shuffled available index
random_index = available_index.pop()

虽然这种方法有额外的 O(n) 内存复杂度，但在实践中它非常高效且快速。

Answer 1

如果您不能使用 numpy，我会保留一组已知包含 None 的索引。每次添加或删除None 时，这组索引都会更新

Answer 2

您的函数可能需要任意长的时间才能返回。特别是，如果没有项目是None，您将进入无限循环。

相反，恢复所有None 的索引并使用random.choices 随机返回其中的k。

import random

def get_random_addr(input_arr, k=1, target=None):
    return random.choices([i for i, v in enumerate(input_arr) if v is target], k=k)

用法

l = [0, None, 2, 3, None, None]

for i in get_random_addr(l, k=2):
    l[i] = i

print(l) # [0, None, 2, 3, 4, 5]

Answer 3

类似于 DeepSpace 的想法，除了 O(1) 内存和 O(n) 时间，但速度更快，因为它只迭代数组中超过一半的槽。

1. 跟踪空槽的数量。
2. 遍历列表。
3. 如果一个槽是空的，返回你的新值，概率为1/number_empty_slots
4. 如果我们没有返回并且槽是空的，则将概率质量重新分配到其他空槽

代码：

def get_random_addr(input_arr, num_empty_slots):
    # num_empty_slots contains the number of empty slots in input_arr
    for index, elem in enumerate(arr): 
        if elem is None: 
            if random.random() < 1 / num_empty_slots:
                return index
            num_empty_slots -= 1

Answer 4

只需先使用enumerate 为您的列表建立索引，过滤掉那些None，然后使用random.choice 选择一个可用空间。

from random import choice
def get_random_addr(input_arr):
    return choice([index for index, value in enumerate(input_arr) if value is None])
print(get_random_addr([None, 1, None, 2]))

这会随机输出0 或2，如果没有更多可用空间，则输出None。

Answer 5

在我的方法中，我在目标数组中选择一个任意地址，如果它是空闲的，我将其添加到输出列表中，但如果不是，我将该地址映射到包含None 的地址，最接近列表的末尾。数组中超出并包括该映射空闲地址的所有条目都将从该列表中删除，因为它们不是空的，或者已经在列表中的其他地方表示。我重复这个过程，削减目标列表的大小，使查找新的空地址变得越来越容易。还有一些其他的小细节可以让它全部工作，但我认为下面的代码可以比我用文字更好地解释这些。

from random import random

def randint(max_val):
    return int(random() * max_val)

def assign(values, target):
    output = []
    mapping = dict()
    mmax = 0
    size = len(target)
    for val in values:
        idx = randint(size)
        while target[idx] != None:
            if idx in mapping:
                idx = mapping.pop(idx)
                mmax = max(mapping or [0])
                break

            min_size = max(idx, mmax)
            try:
                size -= target[size-1:min_size:-1].index(None)
            except:
                size = min_size + 1

            if target[size-1] == None:
                size -= 1
                mapping[idx] = size
                if idx > mmax:
                    mmax = idx
            elif size-1 in mapping:
                size -= 1
                mapping[idx] = mapping.pop(size)
                mmax = max(mapping or [0])

            idx = randint(size)
        target[idx] = val
        output.append(idx)
    return output

请注意，这会修改传递给它的目标列表。如果你不想修改它，你真的有两个选择：实现一些额外的逻辑来检查“空闲”地址是否已经被消耗，或者复制整个列表（在这种情况下，反转它并修补索引, 这样.index() 就可以直接在列表上工作，这无论如何都是主要的时间槽。

我还建议验证它产生的解决方案是否有效。我已经做了一些测试，但我很可能错过了一些东西。