Java 在两个数组中查找重复项_Java

Java 在两个数组中查找重复项

java

Java 在两个数组中查找重复项,java,Java,我的面试问题是在两个数组中找到重复项 array1 = [1,2,4,6,9,50,34]; array2 = [1,5,4,50,24,78,34]; 我知道这方面的代码是使用两个for循环：面试官要求一种迭代次数较多的更好的方法。我能得到一些建议吗？有两个循环的代码是Om*n，其中m和n是数组大小。如果您将一个数组的内容放入一个基于哈希的容器（例如哈希集），然后检查第二个数组的项，检查它们是否在哈希集中，则可以做得更好。这具有Om+n的复杂性，即两个数组中的元素总数是线性的。具有两个循环

我的面试问题是在两个数组中找到重复项

array1 = [1,2,4,6,9,50,34];
array2 = [1,5,4,50,24,78,34];

我知道这方面的代码是使用两个for循环：

面试官要求一种迭代次数较多的更好的方法。我能得到一些建议吗？

有两个循环的代码是Om*n，其中m和n是数组大小。如果您将一个数组的内容放入一个基于哈希的容器（例如哈希集），然后检查第二个数组的项，检查它们是否在哈希集中，则可以做得更好。这具有Om+n的复杂性，即两个数组中的元素总数是线性的。

具有两个循环的代码是Om*n，其中m和n是数组大小。如果您将一个数组的内容放入一个基于哈希的容器（例如哈希集），然后检查第二个数组的项，检查它们是否在哈希集中，则可以做得更好。这具有Om+n的复杂性，即两个数组中的元素总数呈线性。

假设n是两个数组中较大的一个数组的长度，则需要^2次求解

array1 = [1,2,4,6,9,50,34];
array2 = [1,5,4,50,24,78,34];

更好的解决方案是在logn上对这两个数组进行排序然后在两个排序数组上的一次迭代中找到重复项。总运行时间将在logn上。

假设n是两个阵列中较大的一个的长度，则您的解决方案需要^2时间

array1 = [1,2,4,6,9,50,34];
array2 = [1,5,4,50,24,78,34];

更好的解决方案是在logn上对这两个数组进行排序然后在两个排序数组上的一次迭代中找到重复项。

总运行时间将在logn上。

为什么不使用array\u intersect

$a = array(1, 2, 5, 10, 15, 16);
$b = array(1, 4, 5, 6, 10, 13, 15, 19);

print_r(array_intersect($a, $b));

哎呀，我觉得是PHP，不是JS

然后：

为什么不直接使用array\u intersect

$a = array(1, 2, 5, 10, 15, 16);
$b = array(1, 4, 5, 6, 10, 13, 15, 19);

print_r(array_intersect($a, $b));

哎呀，我觉得是PHP，不是JS

然后：

正如达斯宾莱特在我面前所说：

public static void main(String[] args) {
        int[] arr1 = new int[] { 10, 3, 4, 20};
        int[] arr2 = new int[] { 10, 20, 30 };

        //convert arr1 to java.util.Set
        Set<Integer> set1 = new HashSet<Integer>();
        for (int i : arr1) {
            set1.add(i);
        }
        // print the duplicates
        for (int i : arr2) {
            if (set1.contains(i)) {
                System.out.println(i); // print 10 20
            }
        }
    }

正如达斯宾莱特在我面前所说：

public static void main(String[] args) {
        int[] arr1 = new int[] { 10, 3, 4, 20};
        int[] arr2 = new int[] { 10, 20, 30 };

        //convert arr1 to java.util.Set
        Set<Integer> set1 = new HashSet<Integer>();
        for (int i : arr1) {
            set1.add(i);
        }
        // print the duplicates
        for (int i : arr2) {
            if (set1.contains(i)) {
                System.out.println(i); // print 10 20
            }
        }
    }

我又做了一次测试。。。集合和贴图确实比循环快得多

private static int size = 100000;

public static void main(String[] args) {
    int[] array1 = new int[size];
    int[] array2 = new int[size];

    for (int i = 0; i < size; i++) {
        array1[i] = i;
        array2[i] = i + i;
    }

    System.out.println("starting set");
    startTimer();
    compareAgainstSet(array1, array2);
    long set = stopTimer();
    System.out.println("against set: " + set + "ms\n");

    System.out.println("starting map");
    startTimer();
    compareAgainstMap(array1, array2);
    long map = stopTimer();
    System.out.println("against hashmap: " + map + "ms\n");

    System.out.println("starting loops with break");
    startTimer();
    twoLoopsWithBreak(array1, array2);
    long loopsBreak = stopTimer();
    System.out.println("2 loops with break: " + loopsBreak + "ms\n");

    System.out.println("starting loops without break");
    startTimer();
    twoLoopsWithoutBreak(array1, array2);
    long loops = stopTimer();
    System.out.println("2 loops without break: " + loops + "ms\n");

}

private static void twoLoopsWithoutBreak(int[] arr1, int[] arr2) {
    ArrayList<Integer> doubles = new ArrayList<>();
    for (int i : arr1) {
        for (int j : arr2) {
            if (i == j) {
                doubles.add(i);
            }
        }
    }
}

private static void twoLoopsWithBreak(int[] arr1, int[] arr2) {
    ArrayList<Integer> doubles = new ArrayList<>();
    for (int i : arr1) {
        for (int j : arr2) {
            if (i == j) {
                doubles.add(i);
                break;
            }
        }
    }
}

private static void compareAgainstSet(int[] arr1, int[] arr2) {
    ArrayList<Integer> doubles = new ArrayList<>();
    Set<Integer> set1 = new HashSet<Integer>();
    for (int i : arr1) {
        set1.add(i);
    }
    for (int i : arr2) {
        if (set1.contains(i)) {
            doubles.add(i);
        }
    }
}

private static void compareAgainstMap(int[] arr1, int[] arr2) {
    ArrayList<Integer> doubles = new ArrayList<>();
    HashMap<Integer, Integer> hashmap = new HashMap<Integer, Integer>();
    for (int i : arr1) {
        hashmap.put(i, 0);
    }
    for (int i : arr2) {
        if (hashmap.containsKey(i)) {
            doubles.add(i);
        }
    }
}

private static long startTime;

private static void startTimer() {
    startTime = System.currentTimeMillis();
}

private static long stopTimer() {
    return System.currentTimeMillis() - startTime;
}

我又做了一次测试。。。集合和贴图确实比循环快得多

private static int size = 100000;

public static void main(String[] args) {
    int[] array1 = new int[size];
    int[] array2 = new int[size];

    for (int i = 0; i < size; i++) {
        array1[i] = i;
        array2[i] = i + i;
    }

    System.out.println("starting set");
    startTimer();
    compareAgainstSet(array1, array2);
    long set = stopTimer();
    System.out.println("against set: " + set + "ms\n");

    System.out.println("starting map");
    startTimer();
    compareAgainstMap(array1, array2);
    long map = stopTimer();
    System.out.println("against hashmap: " + map + "ms\n");

    System.out.println("starting loops with break");
    startTimer();
    twoLoopsWithBreak(array1, array2);
    long loopsBreak = stopTimer();
    System.out.println("2 loops with break: " + loopsBreak + "ms\n");

    System.out.println("starting loops without break");
    startTimer();
    twoLoopsWithoutBreak(array1, array2);
    long loops = stopTimer();
    System.out.println("2 loops without break: " + loops + "ms\n");

}

private static void twoLoopsWithoutBreak(int[] arr1, int[] arr2) {
    ArrayList<Integer> doubles = new ArrayList<>();
    for (int i : arr1) {
        for (int j : arr2) {
            if (i == j) {
                doubles.add(i);
            }
        }
    }
}

private static void twoLoopsWithBreak(int[] arr1, int[] arr2) {
    ArrayList<Integer> doubles = new ArrayList<>();
    for (int i : arr1) {
        for (int j : arr2) {
            if (i == j) {
                doubles.add(i);
                break;
            }
        }
    }
}

private static void compareAgainstSet(int[] arr1, int[] arr2) {
    ArrayList<Integer> doubles = new ArrayList<>();
    Set<Integer> set1 = new HashSet<Integer>();
    for (int i : arr1) {
        set1.add(i);
    }
    for (int i : arr2) {
        if (set1.contains(i)) {
            doubles.add(i);
        }
    }
}

private static void compareAgainstMap(int[] arr1, int[] arr2) {
    ArrayList<Integer> doubles = new ArrayList<>();
    HashMap<Integer, Integer> hashmap = new HashMap<Integer, Integer>();
    for (int i : arr1) {
        hashmap.put(i, 0);
    }
    for (int i : arr2) {
        if (hashmap.containsKey(i)) {
            doubles.add(i);
        }
    }
}

private static long startTime;

private static void startTimer() {
    startTime = System.currentTimeMillis();
}

private static long stopTimer() {
    return System.currentTimeMillis() - startTime;
}

如果你不想要两个for循环。然后可以使用hashtable。迭代第一个数组并插入hastable。在将第二个数组迭代到哈希表时，检查是否存在该键，如果存在，则该键是重复的，否则为否

使用这种方法，时间复杂度将降低到Okn，其中k是一个常数，即您拥有的数组数，但辅助空间复杂度将增加。

如果您不希望两个for循环。然后可以使用hashtable。迭代第一个数组并插入hastable。在将第二个数组迭代到哈希表时，检查是否存在该键，如果存在，则该键是重复的，否则为否

import java.util.*;
public class Duplicate {

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

    int array1[]= {1,2,4,6,9,50,34};
    int array2[]= {1,5,4,50,24,78,34};

    HashSet<Integer> hashValue=new HashSet<>();
    for(int i=0;i<array1.length;i++) {
        hashValue.add(array1[i]);
    }

    for(int j=0;j<array2.length;j++) {
        if(hashValue.contains(array2[j])) {
            System.out.println("the duplicate value is  "+array2[j]);
        }
    }


}

使用这种方法，时间复杂度将降低到Okn，其中k是一个常数，即您拥有的阵列数，但辅助空间复杂度将增加

import java.util.*;
public class Duplicate {

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

    int array1[]= {1,2,4,6,9,50,34};
    int array2[]= {1,5,4,50,24,78,34};

    HashSet<Integer> hashValue=new HashSet<>();
    for(int i=0;i<array1.length;i++) {
        hashValue.add(array1[i]);
    }

    for(int j=0;j<array2.length;j++) {
        if(hashValue.contains(array2[j])) {
            System.out.println("the duplicate value is  "+array2[j]);
        }
    }


}

}

大量迭代意味着什么？您正在寻找集合交集，它有许多不同的方法。但是他们的实现要比这三线循环复杂得多，即使它们的复杂度要低得多。大量迭代意味着什么？你在寻找集合交集，它有许多不同的方法。但是IMHO他们的实现比这三行循环更复杂，即使他们的复杂性要低得多。这也不是JS，只是Java:-这也不是JS，只是Java:-