Question

如何找到丢失的号码？

给定：两个数组作为输入，找到第一个数组中存在但第二个数组中缺少的数字。

public class Array2 
 {
public void missingnos(int a[],int b[])
{
    for(int i=0;i<a.length;i++)
    {
        for(int j=i+1;j<a.length;j++)
        {
            if(a[i]>a[j])
            {
                int c=a[i];
                a[i]=a[j];
                a[j]=c;
            }
        }
        System.out.print(a[i]);
    }
    for(int i=0;i<b.length;i++)
    {
        for(int j=i+1;j<b.length;j++)
        {
            if(b[i]>b[j])
            {
                int c=b[i];
                b[i]=b[j];
                b[j]=c;
            }
        }
        System.out.print(b[i]);
    }
    int d[]=new int[a.length];
    d=b;
    int missing=0;
    for(int i=0;i<b.length;i++)
    {
        if(a[i]!=d[i])
        {
            missing=a[i];
            break;
        }
    }
    System.out.println();
    System.out.print(missing);
}
public static void main(String[] args) {
    Array2 a2= new  Array2();
    int a[]={1,4,3,5,6};
    int b[]={4,1,5,3};
    a2.missingnos(a,b);

}

}

测试用例：当我删除6＆amp; 3从数组“a”和“b”分别我得到答案3是正确的，但当我不删除我得到答案为0.

为什么会这样？

Answer 1

这是在O（1）辅助空间和O（n）时间内解决此问题的一种方法。解决方案受以下限制： 1）arr2只有一个元素缺少arr1 2）arr2.length = arr1.length-1或arr2将缺少的元素替换为0.

解决方案：只需取两个数组中所有元素的xor即可。结果整数就是答案

代码：

public static void findMissing(){
    // TODO Auto-generated method stub
    int[] arr1={3,7,2,90,34};
    int[] arr2={2,7,34,3};  
    int xor=0;
    for(int i=0;i<arr1.length;i++){
        xor^=arr1[i];
    }
    for(int i=0;i<arr2.length;i++){
        xor^=arr2[i];
    }
    System.out.println("missing number: "+xor);
}

为什么会这样？说arr1 = {1,2,3,4}       和arr2 = {1,2,4}。取所有元素的xor =＆gt;
                              1 ^ 2 ^ 3 ^ 4 ^ 1 ^ 2 ^ 4
                              =（1 ^ 1）^（2 ^ 2）^（4 ^ 4）^ 3
                              = 0 ^ 0 ^ 0 ^ 3
                              = 3

RP-提出的另一种解决方案也非常好，并且在相同的空间和时间复杂度下解决了这个问题，但在计算总和时有可能出现溢出。

Answer 2

您的主要问题是您尝试以过于复杂的方式执行此操作，并在单个方法中执行所有操作。对数组进行排序不是必需的，并且在您执行此操作时效率非常低，并且不会使用为您执行此操作的Arrays.sort()方法。

尝试将问题分解为简单的任务：

查找数组中是否存在数字。这应该是一种方法（boolean isPresent(int number, int[] array)）。
遍历第一个数组，并为每个元素查找它是否存在于第二个数组中。这应该是你的主要方法，使用第一个：

public class Arrays2 {
    public static void main(String[] args) {
        int[] a = {1, 4, 3, 5, 6};
        int[] b = {4, 1, 5, 3};
        findMissingNumber(a, b);
    }

    private static void findMissingNumber(int[] a, int[] b) {
        for (int n : a) {
            if (!isPresent(n, b)) {
                System.out.println("missing number: " + n);
                break;
            }
        }
    }

    private static boolean isPresent(int n, int[] b) {
        for (int i : b) {
            if (n == i) {
                return true;
            }
        }
        return false;
    }
}

Answer 3

当您有不同大小的数组时，只要一个数组到达其最大位置，您就需要停止。这里你的答案是0，因为b数组只有4个元素。

正确的代码是：

int d[]=new int[a.length];
    d=b;
    int missing=0;
    for(int i=0;i<a.length;i++)
    {
        if(i>=b.length || a[i]!=d[i])
        {
            missing=a[i];
            break;
        }
    }
    System.out.println();
    System.out.print(missing);

Answer 4

将此视为高效算法的问题。在数组上使用嵌套循环将为您提供O（n ^ 2）时间复杂度，这是不可取的。

但是如果你使用类似HashSet的东西，你的时间复杂度将是O（m + n），其中m是第一个数组的长度，n是第二个数组的长度。

如下所示

import java.util.ArrayList;
import java.util.HashSet;

public class MissingNumbers {

    public static Integer[] missingNumbers(Integer[] firstArray,Integer[] secondArray) {
        ArrayList<Integer> alDups = new ArrayList<Integer>();
        int dupCount = 0;
        HashSet<Integer> setOfSecondArr = new HashSet<Integer>();
        // Add second array into hash set of integers
        for (int i : secondArray) {
            setOfSecondArr.add(i);
        }
        // Now add the first array, if it gets successfully added to the set
        // it means second array did not have the number
        for (int i : firstArray) {
            if (setOfSecondArr.add(i)) {
                alDups.add(i);
                dupCount++;
            }
        }

        return alDups.toArray(new Integer[dupCount]);
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        for (int i : missingNumbers(new Integer[] { 1, 2, 3, 5, 6 },
                new Integer[] { 1, 2, 4 })) {
            System.out.println(i);
        }
    }

}

Answer 5

我知道这是一个老问题，但可能对某人有所帮助。我们并不需要比较第一个和第二个数组中的每个元素。

从每个数组中取出总和（以避免溢出），并将一个数组的总和减去其他数组的总和。结果是缺少数字。

Answer 6

尝试一下：

static void Main(string[] args)
    {
        int[] a = {1, 4, 3, 5, 6};
        int[] b = {4, 1, 5, 3};
        for (int i = 0; i < a.Length; i++)
        {
            if(!b.Contains(a[i]))
            {
                Console.WriteLine("missing number: " +a[i]);
            }
        }

        Console.ReadKey();
    }

Answer 7

for(int i=0;i<b.length;i++)
{
    if(a[i]!=d[i])
    {
        missing=a[i];
        break;
    }
}

应更改为
for(int i=0;i<min(a.Length,b.length);i++) 因为当两个数组的大小不同时你没有处理大小写。

另外

int d [] = new int [a.length]; d = B;

如果length(b)>length(a)怎么办？你有很多错误，首先尝试在笔和纸上工作，然后转换成代码。

Answer 8

你的逻辑很复杂。当你可以在第一个for循环本身进行比较时，为什么要使用for循环的第二个组合。你只需要显示第一个数组中右边第二个数组中不存在的数字

Answer 9

public class FindMissingNumbers {


    public static void main(String[] args) {
        // TODO Auto-generated method stub

        int i,j,size1,size2;
        boolean flag=false;
        Scanner sc = new Scanner(System.in);

        System.out.println("Enter 1st array lenght");
        size1=sc.nextInt();//input array size
        int[] a=new int[size1];

        System.out.println("Enter "+size1+" Values of 1st array");
        for(i=0;i<size1;i++){
            a[i]=sc.nextInt();//read first array list
        }


        System.out.println("Enter 2st array lenght");
        size2=sc.nextInt();//input array size
        int b[]=new int[size2];
        System.out.println("Enter Values of 2st array");
        for(i=0;i<size2;i++){
            b[i]=sc.nextInt();//read second array list
        }


        System.out.println("Numbers which are not present in 1nd array");
        for(i=0;i<size2;i++)
        {
            flag=false;
            for(j=0;j<size1;j++)
            {
                if(a[j]==b[i]) 
                {
                    break;
                }
                else if(a[j]!=b[j] && j==size1-1){
                    flag=true;
                }
            }
            if(flag==true){
                System.out.println(b[i]);
                flag=false;
            }

        }

    }

}

Answer 10

ld: framework not found CocoaLumberjack
clang: error: linker command failed with exit code 1 (use -v to see invocation)

Answer 11

sum（第一个数组元素）-sum（第二个数组元素）时间复杂度：o（n）+ o（n-1）

如何找到缺失的数字，给定：两个数组作为输入，并找到第一个数组中存在但第二个数组中缺少的数字

11 个答案: