C++ 生成不同于数组1000个元素的新元素

我在一次采访中被问到这个问题。考虑穿孔卡片的情况，其中每个穿孔卡片具有64位图案。有人建议我将每张卡作为

int

，因为每个int都是位的集合

另外，考虑到我有一个数组，其中已经包含了1000张这样的卡。我每次都要生成一个新元素，它不同于以前的1000张卡。数组中的整数（又名卡片）不必排序

<> P>更进一步的，这可能是C++的问题，代码< > 64位INT/COD>来自哪里，如何从数组中生成新的卡片，其中所生成的元素与数组中已经存在的所有元素不同？

int64 generateNewValue(list_of_cards)
{
    return find_max(list_of_cards)+1;
}

注意：正如@amit在下面指出的，如果

INT64\u MAX

已在列表中，则此操作将失败。

---

就我所知，这是你得到O（n）的唯一方法。如果你想处理这个（相当重要的）边缘情况，那么你必须进行某种适当的排序或搜索，这将把你带到O（n log n）。

我认为方法是使用某种哈希。所以你把你的卡存储在一些桶里，比如说基于MOD操作。在创建某种索引之前，在整个数组中循环都是很困难的

如果您了解java中的HashSet实现，您可能会得到一些线索

---

编辑：我假设您希望它们是随机数，如果您不介意的话，下面的序列MAX+1是一个很好的解决方案：）

您可以构建一个已有元素的二叉树，并遍历它，直到找到一个深度不是64且子节点少于两个的节点。然后，您可以构造一个“缺少”的子节点并拥有一个新元素。如果我没有弄错的话，计算速度应该相当快，大约是O（n）的顺序。

有264个64位整数，这个数字太多了

bool seen[1001] = { false };
for each element of the original array
    if the element is in the range 0..1000
        seen[element] = true
find the index for the first false value in seen

如果大于1000，最简单的解决方案就是生成一个 随机64位数字，然后验证它不在 已经生成了数字。（是的可能性 无穷小，但你最好确定。）

由于大多数随机数生成器不生成64位值，因此 剩下的要么是自己写，要么（简单得多）结合 值，例如通过生成8个随机字节，然后

memcpy

uint64\u t

至于验证号码是否已经存在，

std:：find

是 只需要一两个新数字就可以了；如果你要做很多 查找、对表进行排序以及使用二进制搜索都是非常困难的

---

值得的或者某种哈希表。

@arne就快到了。你需要的是一个，它可以在O（n lgn）时间内构建

然后取顶部节点，它将存储一些间隔[i，j]。根据区间树的属性，i-1和j+1都是新密钥的有效候选，除非i=

UINT64_MIN

或j=

UINT64_MAX

。如果两者都为真，则存储了2^64个元素，并且不可能生成新元素。存储新元素，这需要O（lg n）最坏情况下的时间

---

即：init takes O（n lgn），generate takes O（lgn）。两者都是最糟糕的数字。这种方法最大的优点是，顶部节点将不断“增长”（存储更大的间隔）并与其后继节点或前一节点合并，因此树实际上会在内存使用方面收缩，最终每个操作的时间衰减为O（1）。您也不会浪费任何数字，因此您可以继续生成，直到获得2^64个数字。

您可以使用原始数组中不包含的数字创建一个新数组，然后从新数组中选择一个

？O（1）？

此算法具有

O（N lgn）

初始化、

O（1）

查询和

O（N）

内存使用。我假设您有一个整数类型，我将其称为

int64

，它可以表示整数

[0，int64\u max]

对数字进行排序

创建包含间隔的链接列表

[u，v]

插入

[1，第一个数字-1]

对于剩余的每个数字，插入

[上一个数字+1，当前数字-1]

插入

[最后一个数字+1，int64\u max]

现在，您有了一个表示未使用的数字的列表。您只需对它们进行迭代即可生成新的数字。

初始化： 不要对列表排序。 创建一个长度为1000且包含0..999的新数组。 迭代列表，如果任何数字在0..999范围内，则通过将新数组中的值替换为列表中第一项的值，使其在新数组中无效

插入： 对新数组使用递增索引。如果此索引处的新数组中的值不是列表中第一个元素的值，请将其添加到列表中，否则请检查新数组中下一个位置的值。 当新数组用完时，使用1000..1999重新填充它，并如上所述使现有值无效。是的，这是在列表上循环，但不必每次插入都这样做

接近O（1），直到列表变得如此之大，以至于偶尔对其进行迭代以使“new”新数组失效变得非常重要。也许你可以通过使用一个新的数组来缓解这个问题，这个数组的大小一直都是列表的大小吗

Rgds，

---

Martin将它们全部放入一个大小大于1000的哈希表中，然后找到空单元格（这就是停车问题）。为它生成一个密钥。当然，这对于更大的桌子来说效果更好。该表只需要1位条目

编辑：这是鸽子洞原理。 对于散列函数，这需要“模表大小”（或其他一些“半可逆”函数）

unsigned hashtab[1001] = {0,};
unsigned long long long long numbers[1000] = { ... };

void init (void)
{
unsigned idx;

for (idx=0; idx < 1000; idx++) {
    hashtab [ numbers[idx] % 1001 ] += 1; }

}

unsigned long long long long generate(void)
{
unsigned idx;

for (idx = 0; idx < 1001; idx++) {
    if ( !hashtab [ idx] ) break;  }

return idx + rand() * 1001;
}

unsignedhashtab[1001]={0，}；
无符号长数字[1000]={…}；
void init（void）
{
无符号idx；
法罗群岛
#include <algorithm>
#include <iostream>
unsigned array[] = { 98, 1, 24, 66, 20, 70, 6, 33, 5, 41 };

unsigned count = 0;
unsigned index = 0;

int main() {
  std::sort(array, array + 10);
  while ( count < 100 ) {
    if ( count > array[index] )
      ++index;
    else {
      if ( count < array[index] )
        std::cout << count << std::endl;
      ++count;
    }
  }
}