Tags: , , ,

# Intersection of two arrays

Given two unsorted arrays of integers, find intersection of these two arrays. Intersection means common elements in the given two arrays. For example, A = [1,4,3,2,5,6] B = [3,2,1,5,6,7,8,10] intersection of A and B is [ 1,3,2,5,6 ].

Sort array and then use binary search
As given arrays are unsorted, sort one of the arrays, preferably the larger one. Then search each element of another array in the sorted array using binary search. If the element is present, put it into the intersection array.

```class Solution {
public int[] intersection(int[] nums1, int[] nums2) {

int len1 = nums1.length;
int len2 = nums2.length;
Set<Integer> result = new HashSet<>();

for(int i=0; i<len2; i++){
if(binarySearch(nums1, nums2[i]) != -1){
}
}
int i = 0;
int[] resultArray = new int[result.size()];
for(Integer num : result){
resultArray[i++] = num ;
}

return resultArray;
}

private int binarySearch(int[] a, int key) {

for(int i=0; i<a.length; i++){
if(a[i] == key) return i;
}

return -1;
}
}
```

The time complexity of binary search method to find intersection is `O(nlogn)` for sorting and then `O(mlogn)` for searching. Effective time complexity becomes `O((n+m)logn)` which is not optimal.

Sort and use merge to find common elements
Again in this method, sort two arrays first. Then use two pointers to scan both arrays simultaneously. (Please refer to merge part of merge sort ). The difference is we will put only common elements, instead of all.

The time complexity of merge sort method is `O(nlogn) + O(mlogm)` for sorting and then `O(m+n)` for scanning both arrays. It is worst than the binary search method.

Use hash
Create a hash with key as elements from the smaller array (saves space). Then scan through other array and see if the element is present in hash. If yes, put into intersection array else do not.

```package AlgorithmsAndMe;

import com.sun.org.apache.xpath.internal.operations.Bool;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class IntersectionTwoArrays {

public List<Integer> findIntersecton(int[] a, int[] b) {
List<Integer> result = new ArrayList<>();
Map<Integer, Boolean> existingElements = new HashMap<>();

for (int i = 0; i < a.length; i++) {
existingElements.put(a[i], true);
}

for (int i = 0; i < b.length; i++) {
if (existingElements.containsKey(b[i])) {
}
}
return result;
}
}
```

Test case

```package Test;

import AlgorithmsAndMe.DuplicatesInArray;
import AlgorithmsAndMe.IntersectionTwoArrays;

import java.util.List;
import java.util.Set;

public class IntersectonTwoArraysTest {

IntersectionTwoArrays intersectionTwoArrays
= new IntersectionTwoArrays();

@org.junit.Test
public void testIntersectionTwoArrays() {
int [] a = {1,6,3};
int [] b = {1,2,3};
List<Integer> result = intersectionTwoArrays.findIntersecton(a,b);

result.forEach(s -> System.out.println(s));
}
}

```

This method has the complexity of `O(n)` where n is the number of elements in the larger array and extra space complexity of O(m) where m is the number of elements in the smaller array.

These methods to find the intersection of two arrays do not work when there are duplicate elements in any of the array as they will be part of intersection array only once.

Please share if there is something wrong or missing. we would love to hear from you.