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

时间:2016-11-16 13:04:11

标签: java arrays

代码不止一次返回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));

    }
}

9 个答案:

答案 0 :(得分:7)

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

答案 1 :(得分:1)

这是一个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;
}

答案 2 :(得分:0)

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

  

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

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

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

答案 3 :(得分:0)

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

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

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

答案 4 :(得分:0)

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

}

答案 5 :(得分:0)

    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] +" ");
            }
        }
    }

答案 6 :(得分:0)

  

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

答案 7 :(得分:0)

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

答案 8 :(得分:0)

以下是一个简单的 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;
}