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

Question

我有一个带有一些 integer 数字的数组。 说numbers={3,0,1}或说numbers={9,6,4,2,3,5,7,0,1} 。 现在我必须从数组中找出缺失的数字。 根据此示例，每组中只有一个缺失的数字。 第一个错过2，第二个错过8。

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

但是，如果同一组中缺少两个连续的数字，则无法找出。

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++;
        }
    }
}

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

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

所以，也许我会使用List 。 但是在列表中这种类型的索引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

我有一个包含一些整数的数组。 说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不支持的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 2

我有一个包含一些整数的数组。 说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不支持的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 3

我有一个包含一些整数的数组。 说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不支持的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 4

我有一个包含一些整数的数组。 说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不支持的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 5

我有一个包含一些整数的数组。 说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不支持的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 6

我有一个包含一些整数的数组。 说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不支持的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 7

我有一个包含一些整数的数组。 说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不支持的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 8

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 9

        public static void main(String[] args)
        {
        int[] arr = {1, 2, 3, 5};
        System.out.print("Given number is : ");
        for (int a : arr)
        {
            System.out.print(a + " ");
        }
        int lengthOfArray = arr.length + 1;
        int sum = lengthOfArray * (lengthOfArray + 1) / 2;
        int sumOfArrayNumber = 0;

        for (int s : arr)
        {
            sumOfArrayNumber = sumOfArrayNumber + s;
        }
        System.out.println();
        System.out.println("missing number is : " + Integer.valueOf(sum 
        - sumOfArrayNumber));
        }

Answer 10

我有一个包含一些整数的数组。 说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不支持的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可以解决我的问题。 但是，简单的数组是否有可能解决此问题？