Java 给定两个数组作为输入，并查找第一个数组中存在但第二个数组中缺少的数字

如何找到丢失的号码

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

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

}

}

公共类数组2
{
公共无效缺失编号（int a[]，int b[]
{
对于（int i=0；i
for（int i=0；i您的主要问题是，您试图以一种过于复杂的方式来完成它，并且在单个方法中完成所有操作。排序数组是不必要的，按您的方式进行是非常低效的，并且没有使用能够为您完成此操作的
arrays.sort（）
方法

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

查找数组中是否存在数字。这应该是一个方法（
boolean isPresent（int number，int[]数组）
）
迭代第一个数组，对于每个元素，找出它是否存在于第二个数组中。使用第一个数组，这应该是您的主要方法：

当你有不同大小的数组时，你需要在一个数组到达它的最大位置时立即停止。这里你得到的答案是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);

intd[]=新的int[a.length]；
d=b；
int缺失=0；
对于（int i=0；i=b.长度| | a[i]！=d[i]）
{
缺失=a[i]；
打破
}
}
System.out.println（）；
系统输出打印（缺失）；
您的逻辑复杂化了。既然可以在第一个for循环本身中进行比较，为什么还要使用for循环的第二个组合。您只需要显示第二个数组中不存在的第一个数组中的数字就可以了。
请将此视为一个高效算法的问题。在数组上使用嵌套循环将为u O（n^2）不需要的时间复杂度

但是，如果使用哈希集之类的东西，则时间复杂度将为O（m+n），其中m是第一个数组的长度，n是第二个数组的长度

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

}

}

像下面这样

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

}

import java.util.ArrayList；
导入java.util.HashSet；
公共类丢失号{
公共静态整数[]缺少数字（整数[]第一个数组，整数[]第二个数组）{
ArrayList alDups=新的ArrayList（）；
int dupCount=0；
HashSet setofsecondar=新HashSet（）；
//将第二个数组添加到整数的哈希集中
for（int i:secondArray）{
第二组加（i）；
}
//现在添加第一个数组，如果它成功添加到集合中
//这意味着第二个数组没有数字
for（int i:firstArray）{
if（setofsecondar.add（i））{
添加（i）；
dupCount++；
}
}
返回alDups.toArray（新整数[dupCount]）；
}
/**
*@param args
*/
公共静态void main（字符串[]args）{
//TODO自动生成的方法存根
对于（int i:missingNumber）（新整数[]{1,2,3,5,6}，
新整数[]{1，2，4}）{
系统输出打印LN（i）；
}
}
}
我知道这是一个老问题，但可能对某些人有所帮助。我们并不需要比较第一个和第二个数组中的每个元素

只需从每个数组中取和（以长为单位，以避免溢出），然后将一个数组的和与另一个数组的和相减。结果就是缺少的数字。
这里有一种方法可以在O（1）辅助空间和O（n）时间内解决此问题。解决方案受以下约束：

1） arr2在arr1中只缺少一个元素。

2） arr2.length=arr1.length-1或arr2将缺少的元素替换为0

解决方案：只需对两个数组的所有元素进行异或运算，得到的整数就是答案

代码：

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

publicstaticvoidfindmissing（）{
//TODO自动生成的方法存根
int[]arr1={3,7,2,90,34}；
int[]arr2={2,7,34,3}；
int-xor=0；
for（int i=0；i也很好，在相同的空间和时间复杂性下解决了这个问题，但在计算总和时有可能出现溢出。
公共类findmisingnumbers{
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;
            }

        }

    }

}

公共静态void main（字符串[]args）{
//TODO自动生成的方法存根
int i、j、尺寸1、尺寸2；
布尔标志=假；
扫描仪sc=新的扫描仪（System.in）；
System.out.println（“输入第一个数组长度”）；
size1=sc.nextInt（）；//输入数组大小
int[]a=新的int[size1]；
System.out.println（“输入”+size1+“第一个数组的值”）；
对于（i=0；i
Diff（[1,2,3,4][1,2,3]）=[4]
差异（[1,2,2,2]，[1,2]）=[2,2]
差异（[2,2,1,2]，[1,2]）=[2,2]
Diff（[1,1,1,1,1,1,2,2,2,2]，[1,1,2,2]）=[1,1,1,1,2,2,2]
公共静态void main（字符串[]args）{
int[]a={1,2,3,4}；
int[]b={1,2,3}；
Arrays.sort（a）；//排序仅适用于输入示例3。
数组。排序（b）//
List listA=new ArrayList（）；
for（int i=0；i=b.length）{
增加（a[i]）；
}
对于（int j=i；j
试试这个：

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();
    }

static void Main（字符串[]args）
{
int[]a={1,4,3,5,6}；
int[]b={4,1,5,3}；
for（int i=0；i
求和（第一个数组元素）-求和（第二个数组元素）
时间复杂度：o(
 Diff([1,2,3,4] [1,2,3]) = [4] 
 Diff([1,2,2,2], [1,2]) = [2,2] 
 Diff([2, 2, 1, 2], [1,2]) = [2,2]
 Diff([1,1,1,1,1,1,2,2,2,2,2,2], [1,1,2,2]) = [1,1,1,1,2,2,2,2]

public static void main(String[] args) {
        int[] a = {1,2,3,4};
        int[] b = {1,2,3};

        Arrays.sort(a);// The sorting only required for input example 3.
        Arrays.sort(b);//

        List<Integer> listA = new ArrayList<>();

        for( int i = 0; i < a.length; i++ ) {
            if( i >= b.length  ) { 
                listA.add(a[i]);
            }

            for( int j = i; j < b.length; j++ ) {
                if( a[i] == b[j] || listA.contains(a[i])) {
                    break;
                } else {
                    listA.add(a[i]);
                }
            }
        }//end of for loop
        System.out.println(listA);

    }

With is algorithem, only example 4 won't work.

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();
    }