Question

我有一个包含一些整数的数组。说numbers={3,0,1}或说numbers={9,6,4,2,3,5,7,0,1}。现在，我必须从数组中找出丢失的数字。根据此示例，每组中仅缺少一个数字。第一个小姐2和第二个小姐8。

我已经编码了。我的代码不仅可以从指定的集合中找到一个缺失的数字，还可以从给定的集合中找到多个缺失的数字。

但是如果同一集合中缺少两个连续的数字，它将无法找出。

My code
import java.util.Arrays;

public class Missing_number 
{
    public static void main( String args[] )
    {
        int numbers[]={9,6,4,5,7,0,1};
        Arrays.sort(numbers);
        int i=1;

        while ( i < numbers.length ) 
        {
            if ( numbers[i] - numbers[i-1] == 1 ) 
            {
            } 
            else 
            {
                System.out.println( "Missing number is " + ( numbers[i-1] + 1 ) );
            }
            i++;
        }
    }
}

我在想，如果我能够在数组中附加第一个缺失的数字，然后开始搜索，那么代码是什么样的？ numbers={9,6,4,5,7,0,1}现在，此集合中已经缺少8个。现在，我从列表中终止了另外两个元素（2,3）。 输出：根据我的代码：2,8 ，但是也缺少3个，但没有显示。

我在想，如果我能够在数字数组中附加2，那么可能会容易一些。但是众所周知，Java数组是不可变的，因此我们不能增加它的长度。

因此，也许我会使用列表。但是在列表中，不支持这种类型的索引number[0]=something。那我该如何进行。我在使用列表还是仍停留在数组中？

所以我尝试用arraylist创建它。

Mycode(modified version from array)

 public class T1 {
 public static void main(String args[]){
    List<Integer> numbers=new ArrayList<>();
    numbers.add(9);
    numbers.add(6);
    numbers.add(4);
    numbers.add(5);
    numbers.add(7);
    numbers.add(0);
    numbers.add(1);
    Collections.sort(numbers);
    int i=1;
    while(i< numbers.size()) {
        if (numbers.get(i) - numbers.get(i-1) == 1) {

        } else {
            System.out.println("Missing number is " + (numbers.get(i-1) + 1));
            numbers.add((numbers.get(i-1)+1));
            Collections.sort(numbers);
        }
        i++;
    }

    }
}

Arraylist可以解决我的问题。但是，简单的数组是否有可能解决此问题？

Answer 1

此代码使用HashSet：

public static void main(String[] args) {
    int[] numbers = {9, 6, 4, 5, 7, 0, 1};
    Arrays.sort(numbers);
    HashSet<Integer> set = new HashSet<>();

    for (int i = numbers[0]; i < numbers[numbers.length - 1]; i++) {
        set.add(i);
    }

    for (int i = 0; i < numbers.length; i++) {
        set.remove(numbers[i]);
    }

    for (int x : set) {
        System.out.print(x + " ");
    }
}

将打印：

2 3 8

这是它的工作方式：
1.将所有数字从数组的最小数到数组的最大数相加。
2.遍历数组，并从集合中删除数组的每个项目。
3.打印集合中的其余项，它们是数组中所有缺少的项。

Answer 2

将else子句替换为：

for(int j=numbers[i-1] + 1; j <= numbers[i] - 1; j++) {
    System.out.println( "Missing number is " + ( j ) );
}

让我们检查一下情况：{9，6，4，5，7，0，1} 排序后为：{0，1，4，5，6，6，7，9} 现在，如果i在索引2处，它将发现numbers[i]和numbers[i-1]之间的差不等于1（4-1 = 3），现在您需要1到4之间的所有数字分别为2、3，因此您必须从numbers[i-1]到numbers[i]（不包括）循环以实现此目标。

此代码的复杂度是N (O(N))的大O，其中N是数组中最大的元素。

Answer 3

public class MissingElement {
    public static void main(String[] args)
    {
        int[] arr={10,9,8,7,5,4,3,1,2};
        Arrays.sort(arr);
        for(int i=0;i<arr.length-1;i++)
        {
            if(arr[i]+1!=arr[i+1])
            {
                System.out.println(arr[i]+1);
                break;
            }
        }
    }
}

Answer 4

这里有很多问题没有答案。例如，数组总是以零开头吗？，最大可能大小是多少？等。

这是解决此问题的简单方法，

查找集合中的最大数量。
创建一个空的boolean数组，该数组的长度应为您在上一步中找到的最大数字加一个。
扫描您的原始集合，并在索引处将新布尔数组的值设置为等于原始集合中的数字true。
最后扫描您的boolean数组以查找并生成所有值为false的索引。

示例：

原始设置：{1,0,3}

步骤1：集合中的最大数量= 3
步骤2：长度为 3 + 1 的布尔数组-> {false，false，false，false}
步骤3：在扫描boolean数组中的原始设置和设置值时，这将是最终状态-> {true，true，false，true}
步骤4：最后，您将扫描boolean数组以打印 2 ，因为这只是索引值为false的索引

Answer 5

int[] numbers = { 11, 6, 4, 5, 7, 1 };
Arrays.sort(numbers);
int numbersArrayIndex = 0;
for (int i = 0; i < numbers[numbers.length - 1]; i++) {
    if (i == numbers[numbersArrayIndex]) {
        numbersArrayIndex++;
    }
    else {
        System.out.println(i);
    }
}

Answer 6

        int[] a= {0,12,14,15,32};
        Arrays.sort(a);
        for(int i=0;i<a.length-1;i++)
        {
            if(a[i+1]-a[i]>1)
            {
                int temp=a[i+1]-a[i];
                for(int j=1;j<temp;j++) 
                {
                 System.out.print(a[i]+j + " ");
                }
                temp=0;
            }
        }

输出：1 2 3 4 5 6 7 8 9 10 11 13 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

Answer 7

/ //对于正常和重复元素，这将正常工作 1.找到最大号，并创建一个最大号+1的数组 2.将集合中从1到最大的所有数字相加 3.遍历数组，并从集合中删除数组的每个项目。 4.打印集合中的其余项，它们是数组中所有缺少的项。 /

python

}

Answer 8

我不知道这是否对您有帮助，但是可以使用awk来完成。

echo“ 13 2 5 9 4” | xargs | tr“”“ \ n” |排序-n | awk'BEGIN {i = 1}; {if（i！= $ NF）{for（j = i; j <= $ NF; j ++）{if（j！= $ NF）打印j; i ++}}其他i ++}'

1 3 6 7 8 10 11 12

最大的编号在数组中被认为是序列的限制，awk将匹配每个no。带有一个整数序列，如果不匹配，则只需打印编号

从Java数组中找出n个缺失元素

8 个答案: