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

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数组是不可变的，所以我们不能增加它的长度。

所以，也许我会使用 List。但是在列表中这种类型的索引number[0]=something不支持。那我怎么能继续。我是在使用列表还是仍然卡在数组中？

所以我尝试用一​​个数组列表来创建它。

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, 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

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

这里有一个解决这个问题的简单方法，

• 找出集合中的最大数量。
• 创建一个空的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 4

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 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

public static void printMissingNumbers(int[] arr) {
    int length = arr.length;
    int lastIndesx = arr[length - 1];

    while (length != 0) {
        if (arr[length - 1] == lastIndesx) {
            lastIndesx--;
            length--;
        } else {
            System.out.println("missing number :" + lastIndesx);
            lastIndesx--;
        }

    }

}

Answer 8

/*// This will work fine for Normal and duplicate elements
1. Find Largest no and create an array of size Largest+1 
2. Add all numbers from the 1 to till largest in set
3. Iterates through the array and remove every item of the array from the set.
4. Prints the remaining items in the set, which are all the missing items of the array.*/

        int numbers[] = { 3, 1, 5, 5 };

        int Largest = numbers[0];
        for (int i = 0; i < numbers.length; i++) {
            if (numbers[i] > Largest) {
                Largest = numbers[i];
            }
        }
        System.out.println("Largest no in given array -->" + Largest);
        
        HashSet<Integer> set = new HashSet<Integer>();

        int arr[] = new int[Largest+1];
        
         for (int i = 1; i < arr.length; i++) {
         set.add(i);
         }

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

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

Answer 9

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

回显 "13 2 5 9 4" | xargs | tr " " "\n" |排序-n | awk '开始 { i=1}; {if (i!=$NF) {for(j=i;j

1 3 6 7 8 10 11 12

这里最大的没有。在数组中被认为是序列的限制，awk 将匹配每个编号。带有一个整数序列，如果它不匹配，则简单地打印 no.s