Java 从数组中查找缺少的数字

在编写这段代码时，希望获得更好的方法，使用任何算法从已排序或未排序的数组中查找缺失的数字。如果是未排序的数组，我将排序并执行以下操作

private static void identifyMissingValues(Integer[] ar) {

        for(int i = 0; i < (ar.length - 1); i++) {

            int next = ar[i + 1];
            int current = ar[i];
            if((next - current) > 1) {
                System.out.println("Missing Value : " + (current + 1));
            }
        }
    }

private static void identificationmissingvalue（整数[]ar）{
对于（int i=0；i<（ar.length-1）；i++）{
int next=ar[i+1]；
int电流=ar[i]；
如果（（下一个-当前）>1）{
System.out.println（“缺少值：”+（当前+1））；
}
}
}

---

任何比这更快或更好的代码，请建议

我能知道输入和预期输出的数字系列吗？

---

根据你的代码，如果我没有错的话，我觉得序列应该是1的差。

那么你有一个n个元素的数组，它以一个整数i开始，包含从i到i+n的所有整数，对吗？例如：

arr = [1,2,3,4,5]

所以，数组中所有数字的和应该是从i到i+n的数字之和

例如：

sum（arr）=1+2+3+4+5=15

数字1到n之和的公式是

n（n+1）/2

因此，您可以将for循环设置为：

int counter = 0;

for(Integer i : integers)
    counter += i

获取数组中的数字之和

如果数组从1开始，则检查

计数器

变量是否等于

n（n+1）/2

，其中

n

是数组的长度

---

如果数组不是从一开始的，例如

arr=[78,79,80,81]

，那么您需要稍微调整一下这种方法，但我相信您可以找到它。

对数组排序需要

O（n*log（n））

如果将数组的所有元素添加到运行时间

HashSet

（O（n））

中，然后检查

0

和

ar.length-1

之间的每个数字（或相关范围的任意值），则可以做得更好。这将花费

O（n）

时间。

您可以执行以下操作：

Set<Integer> mySet = new TreeSet<Integer>(Arrays.asList(ar));
int min = mySet.first();

for (int i = 0; i < mySet.size(); i++) {
    int number = min + i;
    if (!mySet.contains(number)) {
        System.out.println ("Missing: " + number);
        i--;
    }
}

Set mySet=newtreeset（Arrays.asList（ar））；
int min=mySet.first（）；
对于（int i=0；i

任何比这更快或更好的代码，请建议

---

不没有这样的事情-如果必须访问每个元素，则无法改进

O（n）

算法。

您的方法很好，但我添加了更多内容，因为缺少多个数字

eg : ar={1,2,4,6,10} // Sorted Array

private static void identifyMissingValues(Integer[] ar) {
    for (int i = 0; i < (ar.length - 1); i++) {
        int next = ar[i + 1];
        int current = ar[i];
        if ((next - current) > 1) {
            for (int ind = 1; ind < next - current; ind++)
                System.out.println("Missing Value : " + (current + ind));
        }
    }
}

Integer[]list=新的整数[]{1,12,85,6,10}；
整数previous=null；
数组。排序（列表）；
系统输出打印项次（列表）；
for（int index=0；index1）{
System.out.println（“缺少值”+next）；
索引--；
}
上一个=下一个；
}

使用位集而不是排序

    int[] ar = {7, 2, 6, 8, 10, 4, 3, 2};
    int min = IntStream.of(ar).min().getAsInt();
    BitSet b = new BitSet();
    for (int i : ar)
        b.set(i - min);
    int i = 0;
    while ((i = b.nextClearBit(i + 1)) < b.length())
        System.out.println(i + min);

---

如果序列中只缺少一个数字，您可以将所有的数字相加，将整个预期序列相加，然后从另一个序列中减去一个和，得到缺少的数字。如果一行中缺少两个或更多个数字，则只打印第一个，但您为什么要对其进行排序？@MrD我不想对其进行排序-确实如此（

如果它是未排序的数组，我会排序并执行以下操作。

）。这就是为什么我提供了一种不需要排序的替代方法。@Eran使用哈希集，即时间复杂度（O（n））对于较大的数据集总是执行得更好。对吗？该算法如何告诉您缺少哪些数字？（除非只缺少一个数字，根据问题中的代码，情况似乎不是这样）。我们可以用O（n）以外的任何其他方式重写代码吗找到多个缺失值的算法？@srikanth-是-但效率较低。输出必须是

3 5 7 8 9

。这不是答案。应该像注释一样发布。

Integer [] list = new Integer[]{1, 12, 85, 6, 10};


Integer previous = null;


Arrays.sort(list);

System.out.println(list);


for(int index = 0; index < list.length; index++){


   if(previous == null){
       previous = (Integer) list[index];
       continue;
   }

    Integer next = previous + 1;
    if(((Integer) list[index] - previous) > 1){

        System.out.println("Missing value " + next);
        index--;

    }
    previous = next;


}

    int[] ar = {7, 2, 6, 8, 10, 4, 3, 2};
    int min = IntStream.of(ar).min().getAsInt();
    BitSet b = new BitSet();
    for (int i : ar)
        b.set(i - min);
    int i = 0;
    while ((i = b.nextClearBit(i + 1)) < b.length())
        System.out.println(i + min);

5
9