用于从重复数组中查找丢失元素的Java程序

给定两个除了一个元素之外彼此重复的数组，即其中一个数组中的一个元素丢失，我们需要找到那个丢失的元素。
例子：

Input:  arr1[] = {1, 4, 5, 7, 9}
        arr2[] = {4, 5, 7, 9}
Output: 1
1 is missing from second array.

Input: arr1[] = {2, 3, 4, 5}
       arr2[] = {2, 3, 4, 5, 6}
Output: 6
6 is missing from first array.

一种简单的解决方案是遍历数组并逐个检查元素并在找到不匹配的元素时标记丢失的元素，但这种解决方案需要线性时间过大的数组。
另一种有效的解决方案是基于二进制搜索方法。算法步骤如下：

1. 在更大的数组中开始二分查找，得到 mid 为 (lo + hi) / 2
2. 如果两个数组的值相同，则缺少的元素必须在右侧，因此将 lo 设置为 mid
3. 否则将 hi 设置为 mid 因为如果中间元素不相等，则缺少的元素必须位于较大数组的左侧。
4. 对于单个元素和零元素数组，单独处理一个特殊情况，单个元素本身将是缺失的元素。
   如果第一个元素本身不相等，则该元素将是缺少的元素。/li>
   

下面是上述步骤的实现

Java

// Java program to find missing element
// from same arrays
// (except one missing element)
  
import java.io.*;
class MissingNumber {
  
    /* Function to find missing element based
     on binary search approach. arr1[] is of
     larger size and N is size of it.arr1[] and 
     arr2[] are assumed to be in same order. */
    int findMissingUtil(int arr1[], int arr2[],
                        int N)
    {
        // special case, for only element
        // which is missing in second array
        if (N == 1)
            return arr1[0];
  
        // special case, for first
        // element missing
        if (arr1[0] != arr2[0])
            return arr1[0];
  
        // Initialize current corner points
        int lo = 0, hi = N - 1;
  
        // loop until lo < hi
        while (lo < hi) {
            int mid = (lo + hi) / 2;
  
            // If element at mid indices are
            // equal then go to right subarray
            if (arr1[mid] == arr2[mid])
                lo = mid;
            else
                hi = mid;
  
            // if lo, hi becomes 
            // contiguous, break
            if (lo == hi - 1)
                break;
        }
  
        // missing element will be at hi 
        // index of bigger array
        return arr1[hi];
    }
  
    // This function mainly does basic error
    // checking and calls findMissingUtil
    void findMissing(int arr1[], int arr2[], 
                              int M, int N)
    {
        if (N == M - 1)
        System.out.println("Missing Element is "
        + findMissingUtil(arr1, arr2, M) + "
");
        else if (M == N - 1)
        System.out.println("Missing Element is "
        + findMissingUtil(arr2, arr1, N) + "
");
        else
        System.out.println("Invalid Input");
    }
  
    // Driver Code
    public static void main(String args[])
    {
        MissingNumber obj = new MissingNumber();
        int arr1[] = { 1, 4, 5, 7, 9 };
        int arr2[] = { 4, 5, 7, 9 };
        int M = arr1.length;
        int N = arr2.length;
        obj.findMissing(arr1, arr2, M, N);
    }
}
  
// This code is contributed by Anshika Goyal.

输出 ：

Missing Element is 1

如果输入数组的顺序不同怎么办？
在这种情况下，缺少的元素只是两个数组的所有元素的 XOR。感谢 Yolo Song 的建议。

Java

// Java program to find missing element
// from one array such that it has all 
// elements of other array except one.
// Elements in two arrays can be in any order.
  
import java.io.*;
class Missing {
      
    // This function mainly does XOR of 
    // all elements of arr1[] and arr2[]
    void findMissing(int arr1[], int arr2[], 
                              int M, int N)
    {
        if (M != N - 1 && N != M - 1) {
        System.out.println("Invalid Input");
            return;
        }
  
        // Do XOR of all element
        int res = 0;
        for (int i = 0; i < M; i++)
            res = res ^ arr1[i];
        for (int i = 0; i < N; i++)
            res = res ^ arr2[i];
  
        System.out.println("Missing element is "
                                          + res);
    }
  
    // Driver Code
    public static void main(String args[])
    {
        Missing obj = new Missing();
        int arr1[] = { 4, 1, 5, 9, 7 };
        int arr2[] = { 7, 5, 9, 4 };
        int M = arr1.length;
        int N = arr2.length;
        obj.findMissing(arr1, arr2, M, N);
    }
}
  
// This code is contributed by Anshika Goyal.

输出 ：

Missing Element is 1

有关更多详细信息，请参阅有关从重复数组中查找丢失元素的完整文章！