Question

代码不止一次返回0和公共数字。我希望它返回一个带有公共数字的数组一次！那么如何使用两个数组共有的数字返回数组。我想返回{2,7,4} - 这样的事情。当我尝试返回数组时，我不断超出范围异常。谢谢，百里

public class Test {
    public int findCommonElement(int[] a, int[] b){
        int counter=0;
        int temp= 0;
        int tempCounter = 0;
        for(int i=0; i<a.length; i++){
            temp=a[i];
            tempCounter=0;
            for(int j=0; j<b.length; j++){
                if (temp==b[j]){
                    tempCounter++;  
                }

            }

            if (tempCounter == 1) {
                temp = a[i];

                counter++;

                System.out.println(temp);

            }

        }

        return 0;
    }

    public static void main(String []args){
        int myArray[] = {2,2,7,7,2,1,5,4,5,1,1};
        int myArray2[] = {2,3,4,7,10};


        Test hello = new Test ();
        System.out.println(hello.findCommonElement(myArray, myArray2));

    }
}

Answer 1

findCommonElement method

的替代解决方案

public int[] findCommonElement(int[] a, int[] b){
    List<Integer> array = new LinkedList<Integer>();
    Set<Integer> set = new HashSet<Integer>();
    for(int ele:a){
        set.add(ele);
    }

    for(int ele:b){
        if(set.contains(ele)){
            array.add(ele);
        }
    }

    int[] arr = new int[array.size()];
    for(int i = 0; i < array.size();i++){
        arr[i] = array.get(i);
    }
    return arr;
}

Answer 2

这是一个O（m + n）解决方案：

static ArrayList<Integer> commonElements(int[] array1, int[] array2) {
    int p1 = 0;
    int p2 = 0;
    ArrayList<Integer> common = new ArrayList<Integer>();

    while(true) {
        if (array1[p1] == array2[p2]) {
            common.add(array1[p1]);
        }
        if (p1 == array1.length - 1 || p2 == array2.length - 1) break;
        if (array1[p1 + 1] < array2[p2 + 1]) {
            p1++;
        } else {
            p2++;
        }
    }
    return common;
}

Answer 3

我发现您的代码存在以下问题：

我希望它返回一个包含公共数字的数组！

所以你需要声明你的方法返回一个数组。添加方括号：

public int[] findCommonElement(int[] a, int[] b) {

在您的方法中，您还必须跟踪到目前为止找到的所有常见元素。您可以使用新阵列或更方便地使用ArrayList，或者更方便地使用HashSet（因为该集合会自动消除重复，因此您只能获得每个公共号码一次）。我认为你的意思是counter变量来跟踪新数组中的元素数量，只有数组还没有。

你检查：

if (tempCounter == 1) {

如果号码在b中出现多次，则表示不正确。而是做

if (tempCounter > 0) {

正如我所说，您需要一种方法来过滤a的重复项，因此您不会[2, 2, 7, 7, 2, 4]而只会[2, 7, 4]。您可以使用我提到的集合I，或者您可以使用ArrayList.contains()或引入另一个循环来检查该数字是否已经在您的公共数组中。如果是的话，请不要再添加它。

最后，要打印数组的内容，请使用Arrays.toString()：

    System.out.println(Arrays.toString(hello.findCommonElement(myArray, myArray2)));

Answer 4

基本上，两个元素中的共同元素的数量将是动态的。因此，如果您尝试将公共元素放入数组中，那么就不可能因为您需要声明此数组的大小（在这种情况下将是动态的）。

考虑使用列表。我试图尽可能简化逻辑以及全面的变量名称。

    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;

    public class Test {

    public static void main(String[] args) {

        int myArray[] = { 2, 2, 7, 7, 2, 1, 5, 4, 5, 1, 1 };
        int myArray2[] = { 2, 3, 4, 7, 10 };

        Test hello = new Test();
        System.out.println(hello.findCommonElement(myArray, myArray2));
    }
    /**
     * 
     * @param a
     * @param b
     * @return commonElements
     */
    public List<Integer> findCommonElement(int[] a, int[] b) {

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

        for(int i = 0; i < a.length ;i++) {
            for(int j = 0; j< b.length ; j++) {
                    if(a[i] == b[j]) {  
                    //Check if the list already contains the common element
                        if(!commonElements.contains(a[i])) {
                            //add the common element into the list
                            commonElements.add(a[i]);
                        }
                    }
            }
        }
        return commonElements;
    }
}

Answer 5

使用Java的

O（m + n）解决方案提供了出色的集合数据结构。关键是Hashset中使用的.retainAll（）函数，该函数保留所有常见元素：

值得一提的是，retainAll（）可与任何Collection类一起使用，并在其内部调用contains（）。因此，O（m + n）仅在此处的集合为HashSet的情况下才会出现，因为它给出0（1）查找。如果它是线性的，例如List，则复杂度将为0（n ^ 2）

public class common {

public static void main(String[] args) {

Integer[] arr1 = new Integer[]{1,1,3,4,6,6,7,2,2};
Integer[] arr2 = new Integer[]{1,1,3,2,4,8,9,5,6};
List<Integer> alist = Arrays.asList(arr1);
List<Integer> blist = Arrays.asList(arr2);

HashSet<Integer> aset =  new HashSet<>(alist);
aset.retainAll(blist);

System.out.println(aset);

}

Answer 6

    int arr1[] = {1,2,5,7,89,3};
    int arr2[] = {1,45,87,34,3};

    for(int i=0;i<arr1.length;i++) {
        for(int j=0;j<arr2.length;j++) {
            if(arr1[i] == arr2[j]) {
                System.out.print(arr1[i] +" ");
            }
        }
    }

Answer 7

int x [] = {5，3，7，2，8}; int y [] = {6，3，8，0，2，7，4，9};

    for (int i = 0; i < x.length; i++) {
        for (int j = 0; j < y.length; j++) {
            if (x[i] == y[j]) {
                System.out.println(x[i]);
            }
        }
    }

Answer 8

使用HashSet消除复杂性

import java.util.*;
public class Complexity
{
    public static void main(String args[])
    {
    int arr1[] = {2,2,7,7,2,1,5,4,5,1,1};
        int arr2[] = {2,3,4,7,10};

        HashSet<Integer> map = new HashSet<Integer>();

        for (int i : arr1){
            map.add(i);
        }
        for (int i : arr2) 
        {
            if (!map.contains(i))
        {
            // found duplicate!   
                System.out.println("Not Contain "+i );
        }
       }
    }
}

Answer 9

以下是一个简单的 O(n) 解决方案，它考虑了数组已排序。如果没有，您可以对它们进行排序。这是对@talshahar 提供的解决方案的改进，还涵盖了最后一个常见元素（边缘情况）。

public List<Integer>  getCommon(int[]array1, int[] array2){
    int p1 = 0;
    int p2 = 0;
    ArrayList<Integer> common = new ArrayList<Integer>();
    while(p1<array1.length || p2<array2.length) {       
       if (array1[p1] == array2[p2]) {
           common.add(array1[p1]);
           p1++;p2++;
       }
      
       else if (array1[p1] < array2[p2]) {
           p1++;
       } else {
           p2++;
       }
   }
    return common;
}

在两个整数数组java中查找公共元素

9 个答案: