Java 查找数组中缺失的数字

Question

我正在尝试自己学习 Java 仅 3 周（来自 YouTube 视频和博客），这是我的第一语言。我想编写一个程序来查找升序整数数组中缺失的数字。我找到了一种方法，但只有递增数组中的最后一个数字小于 10 时才有效。比如 1、2、3、4、5、6、7、8、9、10。

我也在互联网上找到了其他程序，但它们都有同样的问题。

我试着用我有限的 3 周知识自己写作并成功了。但我想我走了很长一段路。代码将近 27 行。

让我给你看代码 我有一个包含 9 个元素的整数数组： [12、13、17、18、20、21、24、25、26] 和 14, 15, 16, 19, 22, 23 不见了

public class Exercises {

    public static void main(String[] args) {
        int[] arr = {12, 13, 17, 18, 20, 21, 24, 25, 26};
        int len = arr.length;
        System.out.println("\nArray source: \n" + Arrays.toString(arr));
        
        //for avoiding ArrayIndexOutOfBoundsException
        //error I am creating temp. array with 10 elemets
        //and adding main array elements to temp. array
        int[] tempArr = new int[len + 1];
        for (int i = 0; i < len; i++) {
            tempArr[i] = arr[i];
        }
        
        //adding last element to temp. array
        int max = 0;
        for (int i = 0; i < tempArr.length; i++) {
            if (tempArr[i] > max) {
                max = tempArr[i];
            }
        }
        tempArr[tempArr.length - 1] = max + 1;
        


        System.out.println("\nMissing number(S): ");
        for (int i = 0; i < len - 1; i++) {
            // If it comes to the last loppf main array
            // this will be use temp. arrays' last element to
            // compare main array
            if (i == (len - 1) && (tempArr[i + 1] - arr[i]) > 1) {
                System.out.println(tempArr[i]);
            } else if ((arr[i + 1] - arr[i]) > 1) {
                for (int a = 1; a <= (arr[i + 1] - arr[i]) - 1; a++) {
                    System.out.println(arr[i] + a);
                }
            }
        }
    }
}

Output:
Array source: 
[12, 13, 17, 18, 20, 21, 24, 25, 26]

Missing number(S): 
14
15
16
19
22
23

我得到了我想要的，但是有没有更好的方法来做到这一点？

顺便说一句，如果我想让代码更美观，它会变得很大 :D

public class Exercises {

    public static void main(String[] args) {
        int[] arr = {12, 13, 17, 18, 20, 21, 24, 25, 26};
        int len = arr.length;
        int[] tempArr = new int[len + 1];
        int[] correctArr = new int[MathUtils.max(arr) - MathUtils.min(arr) + 1];
        int countArr = (MathUtils.max(arr) - (MathUtils.max(arr) - MathUtils.min(arr)) - 1);
        for (int i = 0; i < correctArr.length; i++) {
            countArr++;
            correctArr[i] = countArr;
        }

        System.out.println("\nArray source: \n" + Arrays.toString(arr));
        System.out.println("Source should be: \n" + Arrays.toString(correctArr));

        for (int i = 0; i < len; i++) {
            tempArr[i] = arr[i];
        }
        int max = 0;
        for (int i = 0; i < tempArr.length; i++) {
            if (tempArr[i] > max) {
                max = tempArr[i];
            }
        }
        tempArr[tempArr.length - 1] = max + 1;

        int count = 0;
        for (int i = 0; i < len - 1; i++) {
            if (i == (len - 1) && (tempArr[i + 1] - arr[i]) > 1) {
                count++;
            } else if ((arr[i + 1] - arr[i]) > 1) {
                for (int a = 1; a <= (arr[i + 1] - arr[i]) - 1; a++) {
                    count++;
                }
            }
        }

        if (count == 1) {
            System.out.println("\nThere is only one missing number:");
        } else if (count > 1) {
            System.out.println("\nThere are " + count + " missing numbers:");
        }

        for (int i = 0; i < len - 1; i++) {
            if (i == (len - 1) && (tempArr[i + 1] - arr[i]) > 1) {
                System.out.println(tempArr[i]);
            } else if ((arr[i + 1] - arr[i]) > 1) {
                for (int a = 1; a <= (arr[i + 1] - arr[i]) - 1; a++) {
                    System.out.println(arr[i] + a);
                }
            }
        }
    }
}

Output:
Array source: 
[12, 13, 17, 18, 20, 21, 24, 25, 26]
Source should be: 
[12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26]

There are 6 missing numbers:
14
15
16
19
22
23

Answer 1

你看起来把事情复杂化了，因为一个简单的嵌套 for 循环可能就是你所需要的。外层循环遍历数组，直到但不包括最后一个数字，内层循环在数组中的一项到下一项之间循环，从 arr[i] + 到 arr[i + 1]。请注意，如果两个数组项是连续的，则内部循环不会“循环”，因此不需要 if 块：

public class MissingNumber {
    public static void main(String[] args) {
        int[] arr = {12, 13, 17, 18, 20, 21, 24, 25, 26};
        
        System.out.println("missing numbers");
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = arr[i] + 1; j < arr[i + 1]; j++) {
                System.out.println("" + j);
            }
        }
    }
}

输出：

missing numbers
14
15
16
19
22
23

而已

Answer 2

您可以使用List<Integer> 来避免重复相同的计算。

static List<Integer> missingNumbers(int[] a) {
    List<Integer> missingNumbers = new ArrayList<>();
    for (int i = 1, length = a.length; i < length; ++i)
        if (a[i - 1] + 1 < a[i])
            for (int j = a[i - 1] + 1; j < a[i]; ++j)
                missingNumbers.add(j);
    return missingNumbers;
}

public static void main(String[] args) {
    int[] a = {12, 13, 17, 18, 20, 21, 24, 25, 26};
    List<Integer> missingNumbers = missingNumbers(a);
    if (missingNumbers.size() == 1)
        System.out.println("There is only one missing number:");
    else
        System.out.println("There are " + missingNumbers.size() + " missing numbers:");
    for (int n : missingNumbers)
        System.out.println(n);
}

输出：

There are 6 missing numbers:
14
15
16
19
22
23

Answer 3

int[] arr = { 12, 13, 17, 18, 20, 21, 24, 25, 26 };
System.out.println("Array Source:");
System.out.println(Arrays.toString(arr) + "
");
System.out.println("Missing number(s):");
int nextNumber = arr[0] + 1;
for (int i = 1; i < arr.length; i++) {
    while (arr[i] > nextNumber) {
        System.out.println(nextNumber);
        nextNumber++;
    }
    nextNumber++;
}

要用从min 到max 的所有数字填充数组，您可以编写

int[] shouldBe = IntStream.range(min, max + 1).toArray();

在这种特殊情况下

int[] shouldBe = IntStream.range(arr[0], arr[arr.length - 1] + 1).toArray();

Answer 4

公共课缺失数{

public static void main(String args[]){

int arr[]={1,2,3,4,6,7,8,9};

for(int i=arr.length-1;i>0;i--){

如果（arr[i]-1！=arr[i-1]）{

System.out.println(arr[i]-1);

}

}

}

}