查找不在列表中的最小整数

Question

我的一位同事使用的一个有趣的面试问题：

假设给定一个非常长的、未排序的无符号 64 位整数列表。您如何找到列表中没有出现的最小非负整数？

FOLLOW-UP：既然已经提出了通过排序的明显解决方案，你能比 O(n log n) 更快吗？

跟进：您的算法必须在具有 1GB 内存的计算机上运行

澄清：该列表位于 RAM 中，但可能会占用大量内存。预先给你列表的大小，比如 N。

Answer 1

如果数据结构可以就地变异并支持随机访问，那么您可以在 O(N) 时间和 O(1) 额外空间内完成。只需按顺序遍历数组，并且对于每个索引，将索引处的值写入由 value 指定的索引，递归地将该位置的任何值放置到其位置并丢弃值 > N。然后再次遍历数组寻找该位置其中 value 与索引不匹配 - 这是不在数组中的最小值。这会导致最多 3N 次比较，并且只使用几个值的临时空间。

# Pass 1, move every value to the position of its value
for cursor in range(N):
    target = array[cursor]
    while target < N and target != array[target]:
        new_target = array[target]
        array[target] = target
        target = new_target

# Pass 2, find first location where the index doesn't match the value
for cursor in range(N):
    if array[cursor] != cursor:
        return cursor
return N

Answer 2

这是一个使用O(N) 空间的简单O(N) 解决方案。我假设我们将输入列表限制为非负数，并且我们希望找到不在列表中的第一个非负数。

1. 查找列表的长度；假设它是N。
2. 分配N 布尔数组，初始化为所有false。
3. 对于列表中的每个数字X，如果X小于N，则将数组的X'th元素设置为true。
4. 从索引0 开始扫描数组，寻找false 的第一个元素。如果您在索引I 中找到第一个false，那么I 就是答案。否则（即当所有元素都是true）答案是N。

实际上，“N 布尔数组”可能会被编码为“位图”或“位集”，表示为 byte 或 int 数组。这通常会使用更少的空间（取决于编程语言），并且可以更快地完成对第一个 false 的扫描。

---

这就是算法工作的方式/原因。

假设列表中的N 数字不是不同的，或者其中一个或多个大于N。这意味着在0 .. N - 1 范围内必须有至少一个不在列表中的数字。所以寻找最小缺失数的问题必须因此归结为寻找最小缺失数的问题小于N。这意味着我们不需要跟踪大于或等于N 的数字......因为它们不会是答案。

上一段的替代方案是该列表是来自0 .. N - 1 的数字的排列。在这种情况下，步骤 3 将数组的所有元素设置为 true，步骤 4 告诉我们第一个“缺失”数字是 N。

---

算法的计算复杂度为O(N)，比例常数相对较小。它通过列表进行两次线性传递，或者如果列表长度已知以开始，则仅传递一次。不需要表示将整个列表保存在内存中，因此算法的渐近内存使用量正是表示布尔数组所需要的；即O(N) 位。

（相比之下，依赖于内存中排序或分区的算法假设您可以在内存中表示整个列表。在提出问题的形式中，这需要O(N) 64 位字。）

---

@Jorn cmets 认为第 1 步到第 3 步是计数排序的变体。从某种意义上说，他是对的，但差异很大：

• 计数排序需要一个（至少）Xmax - Xmin 计数器数组，其中Xmax 是列表中的最大数字，Xmin 是列表中的最小数字。每个计数器必须能够代表 N 个状态；即假设一个二进制表示，它必须有一个整数类型（至少）ceiling(log2(N)) 位。
• 要确定数组大小，计数排序需要对列表进行初始传递以确定Xmax 和Xmin。
• 因此，最坏情况下的最小空间要求为ceiling(log2(N)) * (Xmax - Xmin) 位。

相比之下，上面介绍的算法在最坏和最好的情况下只需要N位。

但是，这种分析得出的直觉是，如果算法在列表中进行初始传递以寻找零（并在需要时计算列表元素），如果找到的话，它会给出一个更快的答案零。如果很有可能在列表中找到至少一个零，那么这样做绝对值得。而且这个额外的通道不会改变整体的复杂性。

---

编辑：我已将算法的描述更改为使用“布尔数组”，因为人们显然发现我使用位和位图的原始描述令人困惑。

Answer 3

由于 OP 现在已指定原始列表保存在 RAM 中，并且计算机只有 1GB 内存，所以我将冒险预测答案是否为零。

p>

1GB 的 RAM 意味着列表中最多可以包含 134,217,728 个数字。但是有 2⁶⁴ = 18,446,744,073,709,551,616 个可能的数字。因此，0 在列表中的概率是 137,438,953,472 中的 1。

相比之下，我成为struck by lightning this year 的几率是七十万分之一。而我getting hit by a meteorite 的几率约为 10 万亿分之一。因此，由于我被天体过早死亡，我被写在科学期刊上的可能性大约是答案不为零的十倍。

Answer 4

正如在其他答案中指出的那样，您可以进行排序，然后简单地向上扫描，直到找到间隙。

您可以将算法复杂度提高到 O(N) 并保留 O(N) 空间，方法是使用修改后的 QuickSort 消除不是包含间隙的潜在候选者的分区。

• 在第一个分区阶段，删除重复项。
• 分区完成后，查看下分区中的项目数
• 此值是否等于用于创建分区的值？
  • 如果是这样，则表明间隙位于更高的分区中。
    • 继续快速排序，忽略较低的分区
  • 否则间隙在下分区
    • 继续快速排序，忽略更高的分区

这样可以节省大量的计算量。

Answer 5

由于数字都是 64 位长，我们可以在它们上使用radix sort，即 O(n)。对它们进行排序，然后扫描它们，直到找到你要找的东西。

如果最小的数字为零，则向前扫描，直到找到一个间隙。如果最小的数不为零，则答案为零。

Answer 6

为了说明O(N) 思维的缺陷之一，这里有一个使用O(1) 空格的O(N) 算法。

for i in [0..2^64):
  if i not in list: return i

print "no 64-bit integers are missing"

Answer 7

对于节省空间的方法并且所有值都是不同的，您可以在空间O( k ) 和时间O( k*log(N)*N ) 中执行此操作。它节省空间，没有数据移动，所有操作都是基本的（加减）。

1. 设置U = N; L=0
2. 首先对k 区域中的号码空间进行分区。像这样：
   • 0->(1/k)*(U-L) + L, 0->(2/k)*(U-L) + L, 0->(3/k)*(U-L) + L ... 0->(U-L) + L
3. 找出每个地区有多少个号码 (count{i})。 （N*k 步数）
4. 查找第一个未满的区域 (h)。这意味着count{h} < upper_limit{h}。 （k 步数）
5. 如果h - count{h-1} = 1 你得到了答案
6. 设置U = count{h}; L = count{h-1}
7. 转到 2

这可以使用散列来改进（感谢 Nic 这个想法）。

1. 一样
2. 首先对k 区域中的号码空间进行分区。像这样：
   • L + (i/k)->L + (i+1/k)*(U-L)
3. inc count{j} 使用 j = (number - L)/k (if L < number < U)
4. 找到第一个没有 k 个元素的区域 (h)
5. 如果count{h} = 1h 是你的答案
6. 设置U = maximum value in region hL = minimum value in region h

这将在O(log(N)*N) 中运行。

Answer 8

我只是对它们进行排序，然后遍历序列，直到找到一个间隙（包括开头的零和第一个数字之间的间隙）。

就算法而言，这样的事情可以做到：

def smallest_not_in_list(list):
    sort(list)
    if list[0] != 0:
        return 0
    for i = 1 to list.last:
        if list[i] != list[i-1] + 1:
            return list[i-1] + 1
    if list[list.last] == 2^64 - 1:
        assert ("No gaps")
    return list[list.last] + 1

当然，如果您的内存比 CPU grunt 多得多，您可以创建一个包含所有可能的 64 位值的位掩码，并为列表中的每个数字设置位。然后在该位掩码中查找第一个 0 位。这在时间上变成了 O(n) 操作，但在内存需求方面非常昂贵:-)

我怀疑你是否可以改进 O(n)，因为我看不到不涉及至少查看每个数字一次的方法。

该算法的算法如下：

def smallest_not_in_list(list):
    bitmask = mask_make(2^64) // might take a while :-)
    mask_clear_all (bitmask)
    for i = 1 to list.last:
        mask_set (bitmask, list[i])
    for i = 0 to 2^64 - 1:
        if mask_is_clear (bitmask, i):
            return i
    assert ("No gaps")

Answer 9

对列表进行排序，查看第一个和第二个元素，然后开始向上直到有间隙。

Answer 10

你可以在 O(n) 的时间和 O(1) 的额外空间内完成它，尽管隐藏的因素非常大。这不是解决问题的实用方法，但它可能很有趣。

对于每个无符号 64 位整数（按升序）遍历列表，直到找到目标整数或到达列表末尾。如果到达列表末尾，则目标整数是不在列表中的最小整数。如果到达 64 位整数的末尾，则每个 64 位整数都在列表中。

这是一个 Python 函数：

def smallest_missing_uint64(source_list):
    the_answer = None

    target = 0L
    while target < 2L**64:

        target_found = False
        for item in source_list:
            if item == target:
                target_found = True

        if not target_found and the_answer is None:
            the_answer = target

        target += 1L

    return the_answer

这个函数故意保持 O(n) 效率低下。请特别注意，即使在找到答案之后，该函数也会继续检查目标整数。如果函数在找到答案后立即返回，则外部循环运行的次数将受答案大小的限制，答案的大小受 n 的限制。这种变化会使运行时间为 O(n^2)，即使它会快很多。

Answer 11

感谢 egon、swilden 和 Stephen C 对我的启发。首先，我们知道目标值的范围，因为它不能大于列表的大小。此外，一个 1GB 的列表最多可以包含 134217728 (128 * 2^20) 个 64 位整数。

散列部分
我建议使用散列来显着减少我们的搜索空间。首先，对列表的大小进行平方根。对于 1GB 的列表，N=11,586。设置一个大小为 N 的整数数组。遍历列表，并将找到的每个数字的平方根 * 作为哈希值。在您的哈希表中，增加该哈希的计数器。接下来，遍历您的哈希表。您找到的第一个不等于其最大大小的存储桶定义了您的新搜索空间。

位图部分
现在设置一个与新搜索空间大小相等的常规位图，并再次遍历源列表，在找到搜索空间中的每个数字时填写位图。完成后，位图中的第一个未设置位将为您提供答案。

这将在 O(n) 时间和 O(sqrt(n)) 空间内完成。

（*您可以使用诸如位移之类的方法来更有效地执行此操作，并相应地改变存储桶的数量和大小。）

Answer 12

如果一个数字列表中只有一个缺失的数字，找到缺失数字的最简单方法是将系列相加并减去列表中的每个值。最终值是缺失的数字。

Answer 13

 int i = 0;
            while ( i < Array.Length)
            {

                if (Array[i] == i + 1)
                {
                    i++;
                }

                if (i < Array.Length)
                {
                    if (Array[i] <= Array.Length)
                    {//SWap

                        int temp = Array[i];
                        int AnoTemp = Array[temp - 1];
                        Array[temp - 1] = temp;
                        Array[i] = AnoTemp;

                    }
                    else
                       i++;



                }
            }

            for (int j = 0; j < Array.Length; j++)
            {
                if (Array[j] > Array.Length)
                {
                    Console.WriteLine(j + 1);
                    j = Array.Length;
                }
                else
                    if (j == Array.Length - 1)
                        Console.WriteLine("Not Found !!");

            }
        }

Answer 14

我们可以使用哈希表来保存数字。完成所有数字后，从 0 开始运行计数器，直到找到最小值。一个相当好的散列将在恒定时间内散列和存储，并在恒定时间内检索。

for every i in X         // One scan Θ(1)
   hashtable.put(i, i);  // O(1)

low = 0;

while (hashtable.get(i) <> null)   // at most n+1 times
   low++;

print low;

最坏的情况是数组中有n元素，并且是{0, 1, ... n-1}，这种情况下会在n得到答案，仍然保持O(n)。

Answer 15

这是我用 Java 编写的答案：

基本理念： 1- 遍历数组，丢弃重复的正数、零和负数，同时对其余数求和，同时获得最大正数，并将唯一的正数保留在 Map 中。

2- 将总和计算为 max * (max+1)/2。

3- 求第 1 步和第 2 步计算的总和之间的差

4- 再次从 1 循环到 [sums difference, max] 的最小值，并返回第一个不在步骤 1 中填充的映射中的数字。

public static int solution(int[] A) {
    if (A == null || A.length == 0) {
        throw new IllegalArgumentException();
    }

    int sum = 0;
    Map<Integer, Boolean> uniqueNumbers = new HashMap<Integer, Boolean>();
    int max = A[0];
    for (int i = 0; i < A.length; i++) {
        if(A[i] < 0) {
            continue;
        }
        if(uniqueNumbers.get(A[i]) != null) {
            continue;
        }
        if (A[i] > max) {
            max = A[i];
        }
        uniqueNumbers.put(A[i], true);
        sum += A[i];
    }
    int completeSum = (max * (max + 1)) /  2;
    for(int j = 1; j <= Math.min((completeSum - sum), max); j++) {
        if(uniqueNumbers.get(j) == null) { //O(1)
            return j;
        }
    }
    //All negative case
    if(uniqueNumbers.isEmpty()) {
        return 1;
    }
    return 0;
}

Answer 16

正如 Stephen C 巧妙地指出的那样，答案必须是一个小于数组长度的数字。然后我会通过二进制搜索找到答案。这优化了最坏的情况（因此面试官无法在“假设”的病态场景中抓住你）。在采访中，请指出您这样做是为了针对最坏的情况进行优化。

使用二分搜索的方法是从数组的每个元素中减去您要查找的数字，并检查是否有否定结果。

Answer 17

我喜欢“猜测零”的方法。如果数字是随机的，则很可能为零。如果“考官”设置了一个非随机列表，那就加一个再猜：

LowNum=0
i=0
do forever {
  if i == N then leave /* Processed entire array */
  if array[i] == LowNum {
     LowNum++
     i=0
     }
   else {
     i++
   }
}
display LowNum

最坏的情况是 n*N 且 n=N，但实际上 n 很可能是一个很小的数字（例如 1）

Answer 18

我不确定我是否收到了这个问题。但是如果对于列表 1,2,3,5,6 并且缺少的数字是 4，那么可以通过以下方式在 O(n) 中找到缺少的数字： (n+2)(n+1)/2-(n+1)n/2

编辑：对不起，我想我昨晚想得太快了。无论如何，第二部分实际上应该由 sum(list) 代替，这就是 O(n) 的来源。该公式揭示了其背后的思想：对于 n 个连续整数，总和应为 (n+1)*n/2。如果有缺失的数字，总和将等于 (n+1) 个连续整数的总和减去缺失的数字。

感谢您指出我正在考虑一些中间部分的事实。

Answer 19

干得好蚂蚁阿斯玛！我思考了大约 15 分钟的答案，并独立想出了一个与您的想法相似的答案：

#define SWAP(x,y) { numerictype_t tmp = x; x = y; y = tmp; }
int minNonNegativeNotInArr (numerictype_t * a, size_t n) {
    int m = n;
    for (int i = 0; i < m;) {
        if (a[i] >= m || a[i] < i || a[i] == a[a[i]]) {
            m--;
            SWAP (a[i], a[m]);
            continue;
        }
        if (a[i] > i) {
            SWAP (a[i], a[a[i]]);
            continue;
        }
        i++;
    }
    return m;
}

m 表示“考虑到我对第一个 i 输入的了解，并且在输入 m-1 之前对这些值没有任何其他假设，当前可能的最大输出”。

仅当 (a[i], ..., a[m-1]) 是值 (i, ..., m-1) 的排列时，才会返回 m 的值。因此，如果 a[i] >= m 或 a[i]

如果这不是真的但是 a[i] > i 那么知道 a[i] != a[a[i]] 我们知道用 a[a[i]] 交换 a[i] 会增加各自位置的元素数量。

否则 a[i] 必须等于 i 在这种情况下，我们可以增加 i ，因为知道直到并包括该索引的所有值都等于它们的索引。

这不能进入无限循环的证明留给读者作为练习。 :)

Answer 20

来自 Ants 答案的 Dafny 片段显示了原地算法可能失败的原因。 requires 前置条件描述了每一项的值不能超出数组的范围。

method AntsAasma(A: array<int>) returns (M: int)
  requires A != null && forall N :: 0 <= N < A.Length ==> 0 <= A[N] < A.Length;
  modifies A; 
{
  // Pass 1, move every value to the position of its value
  var N := A.Length;
  var cursor := 0;
  while (cursor < N)
  {
    var target := A[cursor];
    while (0 <= target < N && target != A[target])
    {
        var new_target := A[target];
        A[target] := target;
        target := new_target;
    }
    cursor := cursor + 1;
  }

  // Pass 2, find first location where the index doesn't match the value
  cursor := 0;
  while (cursor < N)
  {
    if (A[cursor] != cursor)
    {
      return cursor;
    }
    cursor := cursor + 1;
  }
  return N;
}

将代码粘贴到带有和不带有forall ... 子句的验证器中以查看验证错误。第二个错误是验证者无法为 Pass 1 循环建立终止条件的结果。证明这一点留给更了解该工具的人。

Answer 21

这是 Java 中的一个答案，它不修改输入并使用 O(N) 时间和 N 位加上一个小的恒定内存开销（其中 N 是列表的大小）：

int smallestMissingValue(List<Integer> values) {
    BitSet bitset = new BitSet(values.size() + 1);
    for (int i : values) {
        if (i >= 0 && i <= values.size()) {
            bitset.set(i);
        }
    }
    return bitset.nextClearBit(0);
}

Answer 22

def solution(A):

index = 0
target = []
A = [x for x in A if x >=0]

if len(A) ==0:
    return 1

maxi = max(A)
if maxi <= len(A):
    maxi = len(A)

target = ['X' for x in range(maxi+1)]
for number in A:
    target[number]= number

count = 1
while count < maxi+1:
    if target[count] == 'X':
        return count
    count +=1
return target[count-1] + 1

上述解决方案获得 100%。

Answer 23

1)过滤负数和归零

2)排序/区分

3)访问数组

复杂度：O(N) 或 O(N * log(N))

使用 Java8

public int solution(int[] A) {
            int result = 1;
    boolean found = false;
    A = Arrays.stream(A).filter(x -> x > 0).sorted().distinct().toArray();
    //System.out.println(Arrays.toString(A));
    for (int i = 0; i < A.length; i++) {
        result = i + 1;
        if (result != A[i]) {
            found = true;
            break;
        }
    }
    if (!found && result == A.length) {
        //result is larger than max element in array
        result++;
    }
    return result;
}

Answer 24

一个unordered_set可以用来存储所有的正数，然后我们可以从1迭代到unordered_set的长度，看看第一个没有出现的数。

int firstMissingPositive(vector<int>& nums) {

    unordered_set<int> fre;
    // storing each positive number in a hash.
    for(int i = 0; i < nums.size(); i +=1)
    {
        if(nums[i] > 0)
            fre.insert(nums[i]);
     }

    int i = 1;
    // Iterating from 1 to size of the set and checking 
    // for the occurrence of 'i'

    for(auto it = fre.begin(); it != fre.end(); ++it)
    {
        if(fre.find(i) == fre.end())
            return i;
        i +=1;
    }

    return i;
}

Answer 25

通过基本的javascript解决

var a = [1, 3, 6, 4, 1, 2];

function findSmallest(a) {
var m = 0;
  for(i=1;i<=a.length;i++) {
    j=0;m=1;
    while(j < a.length) {
      if(i === a[j]) {
        m++;
      }
      j++;
    }
    if(m === 1) {
      return i;
    }
  }
}

console.log(findSmallest(a))

希望这对某人有所帮助。

Answer 26

用python它不是最有效的，但是正确的

#!/usr/bin/env python3
# -*- coding: UTF-8 -*-
import datetime

# write your code in Python 3.6

def solution(A):
    MIN = 0
    MAX = 1000000
    possible_results = range(MIN, MAX)

    for i in possible_results:
        next_value = (i + 1)
        if next_value not in A:
            return next_value
    return 1

test_case_0 = [2, 2, 2]
test_case_1 = [1, 3, 44, 55, 6, 0, 3, 8]
test_case_2 = [-1, -22]
test_case_3 = [x for x in range(-10000, 10000)]
test_case_4 = [x for x in range(0, 100)] + [x for x in range(102, 200)]
test_case_5 = [4, 5, 6]
print("---")
a = datetime.datetime.now()
print(solution(test_case_0))
print(solution(test_case_1))
print(solution(test_case_2))
print(solution(test_case_3))
print(solution(test_case_4))
print(solution(test_case_5))

Answer 27

def solution(A):
    A.sort()
    j = 1
    for i, elem in enumerate(A):
        if j < elem:
            break
        elif j == elem:
            j += 1
            continue
        else:
            continue
    return j

Answer 28

这会有所帮助：

0- A is [5, 3, 2, 7];
1- Define B With Length = A.Length;                            (O(1))
2- initialize B Cells With 1;                                  (O(n))
3- For Each Item In A:
        if (B.Length <= item) then B[Item] = -1                (O(n))
4- The answer is smallest index in B such that B[index] != -1  (O(n))