【问题标题】：How do I get the intersection between two arrays as a new array?如何将两个数组之间的交集作为新数组？
【发布时间】：2012-10-27 13:18:32
【问题描述】：

我在各种情况下多次遇到这个问题。尽管我对 C 或 Java 很熟悉，但它对所有编程语言都是通用的。

让我们考虑两个数组（或集合）：

char[] A = {'a', 'b', 'c', 'd'};
char[] B = {'c', 'd', 'e', 'f'};

如何将两个数组之间的共同元素作为一个新数组？在这种情况下，数组 A 和 B 的交集是char[] c = {'c', 'd'}。

我想避免一个数组在另一个数组中的重复迭代，这将将执行时间增加（A 的长度乘 B 的长度），这在大数组的情况下太多了。

有什么方法可以在每个数组中进行单次传递以获取公共元素？

【问题讨论】：

先对数组进行排序。那么你只需要一次通过。
使用 HashSet 存储第一个数组中的所有数据。然后对于第二个数组中的每个元素，检查 HashSet 是否包含（）元素。排序的复杂度是 O(n lg n) 而这种方法的复杂度是 O(n)
什么对你来说更重要？时间效率还是空间效率？
数组的类型实际上是char吗？下面的 cmets 中的一些参数可以通过对类型进行一些限制来解决。例如，如果您没有该类型的合理散列函数（这就是 Java 鼓励您编写散列函数的原因），那么所有关于预期的带有散列表的 O(N) 的内容都会消失。与char 和足够大的输入相反，最快的可能是为每个字符值（通常为 256 或 65536）创建一个包含一个元素的数组，并使用它来记录每个输入中出现的字符。
在没有明确定义什么是“最佳”的情况下，我建议对数组进行排序的这种解决方案：将每个数组项打印在一张纸上，并将每张纸放在一个清楚标记的信封中。将信封邮寄给您的祖母，并附上指示仅退回两个信封中包含的物品以及一些饼干。解决方案不是很快，因为它是 O(USPS^grandmother)，但最好是因为 cookie 很棒。

标签： java c++ c algorithm

【解决方案1】：

foreach element e in array A
    insert e into hash table H

foreach element e in array B
    if H contains e 
        print e

这个算法在时间上是O(N)，在空间上是O(N)。

为了避免多余的空间，您可以使用基于排序的方法。

【讨论】：

@Yola 没有比 O(n) 更快的解决方案；不可能。
请注意，仍然存在重复问题（问题中未指定如何处理），但通常您希望打印每个元素 min{#occurances(A),#occurances(B)} 或只打印一次，而此解决方案会打印它们#occurances(B)次
@Yola 我们可以整天给诗歌打蜡。但是您说“不是最快的方法”，这在实践中是错误的（在预期的情况下，它是最快的解决方案）和在理论上（如果推动你可以实现一个模式，使非线性性能极不可能甚至保证有限域的线性性能）。在典型用例中，这些理论上完美的解决方案都不一定容易确保，但散列已经是典型用例的最快解决方案。
@Yola 不，在哈希表中搜索需要 O(1)。计算哈希需要多长时间取决于键类型，但通常不会比比较两个键慢多少（这在树和排序中是必需的）。特别是对于简单的char 键，它的速度非常快。
如果您限制数据集的大小，一切都需要 O(1) 时间。哈希查找在数据集大小上的 O(1) 达到一定限制，但考虑素数也是如此。由于小常数而不是大 O 表示法，散列很快。

【解决方案2】：

效率的下限是 O(n) - 你至少需要读取所有元素。然后有几种方法：

愚蠢的最简单方法

在数组 2 中搜索数组 1 中的每个元素。时间复杂度 O(n^2)。

排序方法

您只需对数组 1 进行排序，然后使用二进制搜索从数组 2 中搜索元素。时间复杂度：排序O(nlogn)，搜索O(n * logn) = O(nlogn)，总计O(nlogn)。

哈希方法

从数组一元素创建一个哈希表。在哈希表中从第二个表中搜索元素。时间复杂度取决于散列函数。您可以在最佳情况下实现 O(1) 搜索（所有元素将具有不同的哈希值），但在最坏情况下实现 O(n) （所有元素将具有相同的哈希值）。总时间复杂度：O(n^x)，其中 x 是哈希函数效率的一个因子（介于 1 和 2 之间）。

一些哈希函数可以保证构建一个没有冲突的表。但是对于每个元素，建筑不再需要严格的 O(1) 时间。在大多数情况下它将是 O(1)，但如果表已满或遇到冲突，则需要重新哈希表 - 花费 O(n) 时间。这种情况并不经常发生，比干净添加的频率要低得多。所以 AMORTIZED 时间复杂度是 O(1)。我们不关心某些添加需要 O(n) 时间，只要大多数添加需要 O(1) 时间。

但即便如此，在极端情况下，每次插入都必须重新哈希表，因此严格的时间复杂度为 O(n^2)

【讨论】：

不需要重新散列，因为数组的长度可以预先计算，您可以创建大小为n * LF^-1的散列表，其中LF是您预先确定的负载因子。对于任何LF < 1，每个操作的复杂度是O(1)，而不是O(n^LF)，因为您需要的预期读取数是E= 1 + 1*LF + 1*LF^2 + ... + 1*LF^n < CONSTANT（几何级数之和），所以每个操作都是O(1)。也就是说，哈希表的最坏情况仍然是每个操作 O(n)，但平均情况是 O(1)
另外，排序方法可以在O(NlogM)中完成，其中N是较长数组的长度，M是较短数组的长度。
@amit 我同意，但是如果表中存在冲突，仍然需要重新散列。
如果您假设冲突的重新散列解决方案（而不是链接或线性开放寻址） - 那么是的。但这将是O(n) 的平均情况，而不是O(n^LF)。
@Konrad 我不否认这一点。我只是在严格的时间复杂度，最坏的情况下进行操作。

【解决方案3】：

我知道在某些语言中有一些方法可以完全满足您的需求，您是否考虑过查看其中的一些实现？

PHP - array_intersect()

$array1 = array("a" => "green", "red", "blue");
$array2 = array("b" => "green", "yellow", "red");
$result = array_intersect($array1, $array2);
print_r($result);

>> green
   red

Java - List.retainAll

Collection listOne = new ArrayList(Arrays.asList("milan","dingo", "elpha", "hafil", "meat", "iga", "neeta.peeta"));
Collection listTwo = new ArrayList(Arrays.asList("hafil", "iga", "binga", "mike", "dingo"));

listOne.retainAll( listTwo );
System.out.println( listOne );

>> dingo, hafil, iga

【讨论】：

Python 也可以使用sets 来执行此操作。我想许多语言也有一个可以处理这个的集合类型。
我可以打赌 retainAll 的 Arraylist （实际上所有的 List 在 std java 中的实现）执行 O(n^2)。

【解决方案4】：

因为这在我看来像一个字符串算法，我暂时假设它不可能排序这个序列（因此是字符串）然后你可以使用Longest Common Sequence algorithm (LCS)

假设输入大小不变，则问题复杂度为O(nxm)，（两个输入的长度）

【讨论】：

但是，当有O(n+m) 和O(nlog(m)) 时，为什么要使用O(n*m) 复杂的解决方案呢？ :|
LCS如何给出2个字符串的交集？我们可能会错过很多角色。例如s1=[A B D C E F] 和 s2=[C D E F G H] 在这里，LCS 将是 [D E F] 而两个字符串的交集是 [C D E F]！我在这里错过了什么吗？
srbh.kmr，@Gabriel，我不同意你的例子。这不是 LCS 的缺点，但在您的示例中，两个输入只需共享确切的公共序列即可找到匹配项。通常它从左到右运行，但你可以从另一个方向进行。该算法只搜索常见的序列和常见的字符，因此“one”最多与“eno”匹配一个字母。这就是算法的作用，而不是它的缺点
LCS 没有给出这个问题的正确答案，该算法适用于顺序重要的字符串，在这种情况下，交集总是在集合上，顺序无关紧要。 @Gabriel 的简单示例就在现场，我们需要对输入数据进行更多假设才能使其正常工作。考虑到排序约束，哈希答案可能是最好的。
好吧，OP 要求两个数组之间的交集。交集是集合论的一个概念，集合（根据定义）不依赖于其元素的顺序。我并不是说 LCS 出于某种原因不好。我只是声称它不会给你交叉点。这是一种解决问题的算法，但不是（集合）交集问题。如果不将数组视为集合，那么可以，但是您可能不会要求真正的交集。但我理解你假设的重点：如果它是一个数组，它更多的是一个字符串而不是一个集合。

【解决方案5】：

    public static void main(String[] args) {
        char[] a = {'a', 'b', 'c', 'd'};
        char[] b = {'c', 'd', 'e', 'f'};
        System.out.println(intersect(a, b));
    }

    private static Set<Character> intersect(char[] a, char[] b) {
        Set<Character> aSet = new HashSet<Character>();
        Set<Character> intersection = new HashSet<Character>();
        for (char c : a) {
            aSet.add(c);
        }
        for (char c : b) {
            if (aSet.contains(c)) {
                intersection.add(c);
            }
        }
        return intersection;
    }

【讨论】：

性能将略低于最佳，因为您实际上不需要创建第二个集合来检查它是否包含第二个集合中的元素。
我还会检查大小，如果 b 很大而 a 很小，您的代码在检查较大的集合时会运行得更慢
@user1281385 但是在这种情况下，处理字符，contains() 无论集合的大小如何，总是具有 O(1) 复杂度。

【解决方案6】：

int s[256] // for considering all ascii values, serves as a hash function

for(int i=0;i<256;i++)
s[i]=0;

char a[]={'a','b','c','d'};
char b[]={'c','d','e','f'};

for(int i=0;i<sizeof(a);i++)
{
   s[a[i]]++;
 }

 for(int i=0;i<sizeof(b);i++)//checker function
 {
     if(s[b[i]]>0)
       cout<<b[i]; 
  }


  complexity O(m+n);
  m- length of array a
  n- length of array b

【讨论】：

【解决方案7】：

谷歌番石榴

已经有很多很好的答案，但如果你想要使用惰性编码库的单线方法，我会选择 Google Guava（用于 Java）及其 Sets.intersection 方法。

^{（手头没有编译器，请耐心等待）}

char[] A = {'a', 'b', 'c', 'd'};
char[] B = {'c', 'd', 'e', 'f'};

Set<Character> intersection = Sets.intersection(
    Sets.newHashSet<Character>(Chars.asList(a)),
    Sets.newHashSet<Character>(Chars.asList(b))
);

显然，这是假设两个数组都没有重复项，在这种情况下，使用集合数据结构会更有意义，并且可以更有效地进行此类操作，尤其是如果您不从基元数组开始从一开始。

可能适合也可能不适合您的用例，但对于一般情况来说是一种不费吹灰之力的方法。

【讨论】：

【解决方案8】：

对两个数组进行排序。
然后循环，直到它们有共同的元素或数组之一到达其末尾。

渐近地，这需要排序的复杂性。即 O(NlogN) 其中 N 是较长输入数组的长度。

【讨论】：

可以改进为O(NlogM)（N是较大的arra的长度，M是较短的），只对较短的数组进行排序，对较长的数组中的每个元素进行迭代+二分查找。

【解决方案9】：

如果您关心重复，请使用哈希映射来索引列表 A，键是元素，值是该元素被看到的次数。

您遍历 A 中的第一个元素和每个元素，如果它在地图中不存在，则将其放入其中，值为 1，如果它已存在于地图中，则将其添加到该值。

接下来，遍历 B，如果值存在，则减 1。如果不存在，则将 -1 放入表中该元素的值中。

最后，遍历地图，对于任何值为 != 0 的元素，打印出差异。

private static <T> List<T> intersectArrays(List<T> a, List<T> b) {
    Map<T, Long> intersectionCountMap = new HashMap<T, Long>((((Math.max(a.size(), b.size()))*4)/3)+1);
    List<T> returnList = new LinkedList<T>();
    for(T element : a) {
        Long count = intersectionCountMap.get(element);
        if (count != null) {
            intersectionCountMap.put(element, count+1);
        } else {
            intersectionCountMap.put(element, 1L);
        }
    }
    for (T element : b) {
        Long count = intersectionCountMap.get(element);
        if (count != null) {
            intersectionCountMap.put(element, count-1);
        } else {
            intersectionCountMap.put(element, -1L);
        }            
    }
    for(T key : intersectionCountMap.keySet()) {
        Long count = intersectionCountMap.get(key);
        if (count != null && count != 0) {
            for(long i = 0; i < count; i++) {
                returnList.add(key);
            }
        }
    }
    return returnList;
}

这应该在O(n) 中运行，因为我们只对 Lists 进行一次迭代，对 Map 进行一次迭代。 Java 中使用的数据结构应该是高效的，因为HashMap 的构造容量可以处理最大大小的列表。

我使用LinkedList 作为返回值，因为它为我们提供了一种为未知大小的交集添加和迭代列表的方法。

【讨论】：

【解决方案10】：

最好的方法是根本不要从数组开始。数组最适合随机访问元素，但不是最适合搜索（这就是找到交集的全部意义所在）。当您谈论 intersection 时，您必须将数组视为集合。所以使用更合适的数据结构（Java 中为Set）。这样任务就更有效率了。

【讨论】：

视情况而定。对于少量数据点（~小于 15），数组是最快的搜索数据结构。
……顺便提一下，Java中的Set是一个接口，可以用线性数组来实现。

【解决方案11】：

您可以使用树，但时间将是 O(n(log n)) 并且元素必须具有可比性

【讨论】：

对于与排序解决方案相关的常量数据，树的效率非常低。它的主要原因是缓存 - 数组比树缓存效率高得多。（虽然是O(nlogn)，和sort和iterate一样，但是隐藏的常数会高很多）

【解决方案12】：

首先，使用最佳排序算法对两个数组进行排序。
然后，通过线性搜索，你可以得到共同的元素。

如果提供了额外的空间，那么我们可以使用哈希表来做到这一点。

【讨论】：

【解决方案13】：

在 ruby 中你可以说

a = ['a', 'b', 'c', 'd']
b = ['c', 'd', 'e', 'f']
c = a & b

c 包含 ['c','d']

【讨论】：

【解决方案14】：

先对两个数组进行排序，然后迭代，如果是相同的元素，就加到返回数组中。

代码在这里：

public static void printArr(int[] arr){
    for (int a:arr){
        System.out.print(a + ", ");
    }
    System.out.println();
}

public static int[] intersectionOf(int[] arr1, int[] arr2){
    Arrays.sort(arr1);
    Arrays.sort(arr2);

    printArr(arr1);
    printArr(arr2);

    int i=0, j=0, k=0;
    int[] arr = new int[Math.min(arr1.length, arr2.length)];

    while( i < arr1.length && j < arr2.length){
        if(arr1[i] < arr2[j]){
            i++;
        } else if(arr1[i] > arr2[j]){
            j++;
        } else {
            arr[k++] = arr1[i++];
            j++;
        }
    }
    return Arrays.copyOf(arr, k);
}

public static void main(String[] args) {
    int[] arr1 = {1, 2, 6};
    int[] arr2 = {10, 2, 5, 1};
    printArr(intersectionOf(arr1,arr2));
}

输出：

arr1: 1, 2, 6, 
arr2: 1, 2, 5, 10, 
arr: 1, 2,

【讨论】：

【解决方案15】：

假设您正在处理 ANSI 字符。对于 Unicode，方法应该类似，只需更改范围即可。

char[] A = {'a', 'b', 'c', 'd'};
char[] B = {'c', 'd', 'e', 'f'};
int[] charset = new int[256]

for(int i=0; i<A.length; i++) {
  charset[A[i]]++;
}

现在对 B 进行迭代，您可以检查被迭代字符的相应字符集值是否大于 0。您可以将它们存储在列表或任何其他集合中。

这种方法需要 O(n) 时间复杂度和用于检查的恒定空间，而不考虑用于保存公共元素的新数组/列表。

就空间复杂度而言，这比 HashSet/Hashtable 方法要好。

【讨论】：

Unicode 的范围是（理论上）32 位——这将需要 16 GiB 的 RAM 用于您的 charset 表。你明白人们为什么使用哈希表了吗？
@KonradRudolph 我认为这真的取决于问题以及人们愿意做出的权衡。如果我们正在处理比较 TB 的文件，那么如果您想坚持使用一台机器，那么固定大小的字符集表将是一种更可行的方法。
@KonradRudolph 如果我们知道我们正在处理 ASCII 字符串，则上述情况也可以随时击败哈希表方法。
继续梦想。 Unicode 数组将是 4 GiB 大。即使我们有足够的 RAM，随机访问模式也会降低缓存性能。哈希表会更快。
对于大型数据集，插入哈希表不是 O(n) 吗？怎么会更快？我认为在处理大型数据集时，map-reduce 方法可能是解决此问题的更好方法。

【解决方案16】：

您可以在 .NET 3.5 或更高版本中使用 HashSet。示例 c# 代码：

HashSet<int> set1 = new HashSet<int>(new int[]{8, 12, 13, 15});

HashSet<int> set2 = new HashSet<int>(new int[] { 15, 16, 7, 8, 9 });

set1.IntersectWith(set2);

foreach (int i in set1)

   Console.Write(i+ " ");

//输出：8 15

【讨论】：

【解决方案17】：

对数组之一进行排序 (m Log(m) ) 现在从其他数组中挑选每个元素并在第一个数组（排序的）中进行二进制搜索 ->n Log(m)

总时间复杂度：- (n+m)Log(m).

【讨论】：

【解决方案18】：

我希望以下内容对您有所帮助。这是两种不同的方法：

比较一个数组中所有元素的简单交集到另一个数组。
基于排序和搜索的方法，该方法对一个数组进行排序并使用二进制搜索第一个数组中的第二个数组元素搜索。

//

public class IntersectionOfUnsortedArrays {
    public static void main(String[] args) {
        int[] arr1 = { 12, 4, 17 };
        int[] arr2 = { 1, 12, 7, 17 };
        System.out.println("Intersection Using Simple Comparision");
        printArray(simpleIntersection(arr1, arr2));
        System.out.println("Intersection Using Sort and Binary Search");
        printArray(sortingBasedIntersection(arr1, arr2));
    }

    /*
     * Simple intersection based on the comparison without any sorting.
     * Complexity O(n^2)
     */
    public static int[] simpleIntersection(int[] a, int[] b) {
        int minlen = a.length > b.length ? b.length : a.length;
        int c[] = new int[minlen];
        int k=0;
        for(int i=0;i<a.length;i++){
            for(int j=0;j<b.length;j++){
                if(a[i]==b[j]){
                    c[k++]=a[i];
                }
            }
        }
        int arr[] = new int[k];
        // copy the final array to remove unwanted 0's from the array c
        System.arraycopy(c, 0, arr, 0, k);
        return arr;
    }

    /*
     * Sorting and Searching based intersection.
     * Complexity Sorting O(n^2) + Searching O(log n)
     */

    public static int[] sortingBasedIntersection(int[] a, int[] b){
        insertionSort(a);
        int minlen = a.length > b.length ? b.length : a.length;
        int c[] = new int[minlen];
        int k=0;
        for(int i=0;i<b.length;i++){
            int result = binarySearch(a,0,a.length,b[i]);
            if(result > -1){
                c[k++] = a[result];
            }
        }
        int arr[] = new int[k];
        // copy the final array to remove unwanted 0's from the array c
        System.arraycopy(c, 0, arr, 0, k);
        return arr;
    }

    public static void insertionSort(int array[]) {
        for (int i = 1; i < array.length; i++) {
            int j = i;
            int b = array[i];
            while ((j > 0) && (array[j - 1] > b)) {
                array[j] = array[j - 1];
                j--;
            }
            array[j] = b;
        }
    }

    static int binarySearch(int arr[], int low, int high, int num) {
        if (high < low)
            return -1;
        int mid = (low + high) / 2;
        if (num == arr[mid])
            return mid;
        if (num > arr[mid])
            return binarySearch(arr, (mid + 1), high, num);
        else
            return binarySearch(arr, low, (mid - 1), num);
    }

    public static void printArray(int[] array) {
        for (int value : array) {
            System.out.print(" "+value);
        }
        System.out.println("\n");
    }
}

【讨论】：

【解决方案19】：

如果集合已经排序，如问题所示，那么最好的解决方案（尚未提及）是在 O(n+m) 中运行的类似合并排序的算法。

比较每个集合的第一个元素。如果它们相同，则将元素添加到交集并从它们的集合中弹出两个元素。如果元素不同，则弹出与另一个元素相比更大的元素。重复直到一个集合为空。

【讨论】：

【解决方案20】：

使用 Java 8 特性，这里有一个算法，它尊重列表中的重复项，而不是将列表变成集合。没有排序，所以没有n log n。

将其中一个列表转换为地图，值为出现次数（成本：O(n)）。
对于另一个列表中的每个项目，如果该项目存在于地图中，则将出现次数减少一（成本：O(n)）。

因此，总成本为 O(n)。代码：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class Dup {
  public static void main(String[] args) {
    List<Integer> listA = Arrays.asList(3, 1, 4, 1, 9, 5, 9);
    List<Integer> listB = Arrays.asList(2, 6, 5, 3, 5, 8, 9, 7, 9, 3, 2, 3);
    findCommons(listA, listB);
  }

  static void findCommons(List<Integer> listA, List<Integer> listB) {
    Map<Integer, Long> mapA = 
        listA.stream().collect(
            Collectors.groupingBy(Integer::intValue, Collectors.counting()));

    List<Integer> commons = new ArrayList<>();
    listB.stream()
        .filter(e -> mapA.get(e) != null)
        .filter(e -> mapA.get(e) > 0)
        .forEach(e -> {
            mapA.put(e, mapA.get(e) - 1);
            commons.add(e);
        });

    System.out.println(commons);
  }
}

上面的代码会给出这个输出：[5, 3, 9, 9]。

【讨论】：

【解决方案21】：

导入 java.util.Scanner;

公共类arraycommon {

public static void main(String[] args) {
    Scanner sc=new Scanner(System.in);
    // display common element in two diffrent array
    int sizea,sizeb,i=0,j=0,k=0;
    int count=0;
    System.out.println("enter the size array A:"+'\n');
    sizea=sc.nextInt();
    System.out.println("enter the size array B"+'\n');
    sizeb=sc.nextInt();
    int a[]=new int[sizea];
    int b[]=new int[sizeb];
    int c[]=new int[sizea];


    System.out.println("enter the element in array A:"+'\n');
    for (i = 0; i < sizea; i++) {

        a[i]=sc.nextInt();
    }
    System.out.println("enter the element in array B:"+'\n');
    for (i = 0; i < sizeb; i++) {

        b[i]=sc.nextInt();
    }
    System.out.println("the element in array A:"+'\n');
    for (i = 0; i < sizea; i++) {

        System.out.print(a[i]+" ");

    }
    System.out.println('\n');
    System.out.println("the element in array B:"+'\n');
    for (i = 0; i < sizeb; i++) 
    {

        System.out.print(b[i]+" ");
    }

    for (i = 0; i <sizea; i++) 
    {
        for (j = 0; j < sizeb; j++) 
        {
           if(a[i]==b[j])
           {
               count++;
               c[k]=a[i];
               k=k+1;
           }
        }
    }
    System.out.println('\n');
    System.out.println("element common in array is");

    if(count==0)
    {
        System.out.println("sorry no common elements");
    }
    else
    {
        for (i = 0; i <count; i++) 
        {

        System.out.print(c[i]+" ");
        }
    }

}

}

【讨论】：

对代码的一些解释将使这个答案更有帮助。

【解决方案22】：

    simply search each element of first array with each element of second array and stored matched result in third array
class Union
{
  public static void main(String[] args) {
  char a[] ={'f','g','d','v','a'};
  char b[] ={'a','b','c','d','e'};
  char temp[] = new char[5];
  int p=0;
  for(int i=0;i<a.length;i++)
  {
    for(int j=0;j<b.length;j++)
    {
      if(a[i]==b[j])     //searches if both array has common element
      {

        temp[p] = a[i];   //if match found store it in a new array
        p++;
      }

    }

  }
  for(int k=0;k<temp.length;k++)
  {
      System.out.println(temp[k]);
  }

  }
}

【讨论】：

这是蛮力的方法，效率不高。