JavaScript Program to Find Union and Intersection of Two Unsorted Arrays
Last Updated :
26 Oct, 2023
In this article, we will learn how to find the Union and Intersection of two arrays. When an array contains all the elements that are present in both of the arrays, it is called a union. On the other hand, if an array has only those elements that are common in both of the arrays, then it is called an intersection.
Example
Input:
a = [1,3,5,7,9] , b = [1,2,3,4,6,8,10]
Output:
Union: [1,2,3,4,5,6,7,8,9,10]
Intersection: ans =[1,3]
We will understand the various approaches for finding the union and the intersection of two unsorted Arrays.
Using Set
Union:
- Creating functions and passing both arrays and their respective lengths.
- Initializing a set as a union set.
- Iterating both of the arrays and storing elements in the set.
- After sorting the printing elements of the set.
Intersection:
- Creating a function and passing both arrays and their respective lengths.
- Initializing 2 sets one for storing union and another for storing intersection.
- Iterating the array and checking if that value is already present in the union set.
- We will add those elements of the array which are already present in the union set.
- Creating an array and storing the value of the intersection set into it and printing the array.
Example: This example describes the union & intersection of 2 unsorted Arrays by implementing the Set.
Javascript
function getIntersection(a, n, b, m) {
let unionSet = new Set();
let intersectionSet = new Set();
for (let i = 0; i < n; i++)
unionSet.add(a[i]);
console.log( "Intersection:" );
for (let i = 0; i < m; i++) {
if (unionSet.has(b[i])) {
intersectionSet.add(b[i]);
}
}
let ans = [];
for (let k of intersectionSet) {
ans.push(k);
}
console.log(ans);
}
function getUnion(a, n, b, m) {
let s = new Set();
for (let i = 0; i < n; i++)
s.add(a[i]);
for (let i = 0; i < m; i++)
s.add(b[i]);
let arr = [];
for (let itr of s)
arr.push(itr);
arr.sort( function (a, b) { return a - b; })
console.log( "union:" );
console.log(arr);
}
let a = [1, 2, 5, 6, 2, 3, 5, 7, 3];
let b = [2, 4, 5, 6, 8, 9, 4, 6, 5, 4];
getUnion(a, a.length, b, b.length);
getIntersection(a, a.length, b, b.length);
|
Output
union:
[
1, 2, 3, 4, 5,
6, 7, 8, 9
]
Intersection:
[ 2, 5, 6 ]
Time Complexity: O((n + m) * log(n + m)) for both union and intersection.
Space Complexity: O(n + m) for the union and O(min(n, m)) for the intersection.
Using the map
Union:
- Creating functions and passing both arrays and their respective lengths.
- Initializing a map mp and storing the element’s key value pairwise.
- Iterating mp and storing unique value using mp.keys() function into an array.
- Printing array in the console.
Intersection:
- Creating functions and passing both arrays and their respective lengths.
- Initializing a map mp and storing the elements of the first array in key-value pairwise
- Iterating the second array and checking for the presence of each element in the mp map, If that element is present in mp then we will add that element into the intersection array.
- And will delete that element from mp for the avoidance of duplicates in the intersection array.
Example: This example describes the union & intersection of 2 unsorted Arrays by implementing the Map.
Javascript
function printUnion(a, n, b, m) {
let mp = new Map();
for (let i = 0; i < n; i++) {
mp.set(a[i], i);
}
for (let i = 0; i < m; i++) {
mp.set(b[i], i);
}
let ans = [];
for (let key of mp.keys()) {
ans.push(key)
}
console.log(ans);
}
function getIntersection(a, n, b, m) {
let mp = new Map();
let ans = [];
for (let i = 0; i < n; i++) {
mp.set(a[i], i);
}
console.log( "Intersection:" );
for (let i = 0; i < m; i++) {
if (mp.has(b[i])) {
ans.push(b[i]);
mp. delete (b[i]);
}
}
console.log(ans);
}
let a = [1, 2, 5, 6, 2, 3, 5, 7, 3];
let b = [2, 4, 5, 6, 8, 9, 4, 6, 5, 4];
printUnion(a, a.length, b, b.length);
getIntersection(a, a.length, b, b.length);
|
Output
[
1, 2, 5, 6,
3, 4, 8, 9
]
Intersection:
[ 2, 5, 6 ]
Time Complexity: O(m * log(m) + n * log(n))
Auxiliary Space: O(m + n)
Use Sorting
Union:
- The first step is to sort both arrays.
- Now, use the two-pointer approach, if the current element is smaller then store it in ans.
- Else, if elements are equal then simply store either the first array element or the second array.
Intersection:
- The first step is to sort both arrays.
- Now, use the two-pointer approach, if the current element is smaller then increment the first array otherwise increment the second array.
- If elements are equal then simply store the element in the ans array.
Example: This example describes the union & intersection of 2 unsorted Arrays by implementing the Sorting.
Javascript
function printUnion(arr1, arr2, m, n) {
arr1.sort( function (a, b) { return a - b; });
arr2.sort( function (a, b) { return a - b; });
let i = 0;
let j = 0;
let ans = [];
while (i < m && j < n) {
if (arr1[i] < arr2[j])
ans.push(arr1[i++]);
else if (arr2[j] < arr1[i])
ans.push(arr2[j++]);
else {
ans.push(arr2[j++]);
i++;
}
}
while (i < m)
ans.push(arr1[i++]);
while (j < n)
ans.push(arr2[j++]);
console.log(ans);
}
function printIntersection(arr1, arr2, m, n) {
arr1.sort( function (a, b) { return a - b; });
arr2.sort( function (a, b) { return a - b; });
let i = 0;
let j = 0;
let ans = [];
while (i < m && j < n) {
if (arr1[i] < arr2[j])
i++;
else if (arr2[j] < arr1[i])
j++;
else {
ans.push(arr2[j++])
i++;
}
}
console.log(ans);
}
let arr1 = [7, 1, 5, 2, 3, 6];
let arr2 = [3, 8, 6, 20, 7];
let m = arr1.length;
let n = arr2.length;
console.log( "Union of two arrays is : " );
printUnion(arr1, arr2, m, n);
console.log( "Intersection of two arrays is : " );
printIntersection(arr1, arr2, m, n);
|
Output
Union of two arrays is :
[
1, 2, 3, 5,
6, 7, 8, 20
]
Intersection of two arrays is :
[ 3, 6, 7 ]
Time complexity: O(mLogm + nLogn)
Space Complexity: O(m + n)
Use Sorting and Searching
Union:
- Sort the smaller array, arr1, in ascending order.
- Initialize an empty array ans to store the union.
- Iterate through arr1 and add its elements to the ans array. For each element in arr2, check if it’s already in the ans array using binary search. If not found, add it to the ans array.
Intersection:
- Determine the smaller array between arr1 and arr2. If arr1 is larger, swap them.
- Sort the smaller array, arr1, in ascending order.
- Initialize an empty array ans to store the intersection.
- Iterate through arr1 and use binary search to check if each element exists in the larger array, arr2. If found in both arrays, add it to the ans array.
Example: This example describes the union & intersection of 2 unsorted Arrays by implementing Sorting and searching.
Javascript
function binarySearch(arr, l, r, x) {
if (r >= l) {
let mid = l + Math.floor((r - l) / 2);
if (arr[mid] == x)
return mid;
if (arr[mid] > x)
return binarySearch(arr, l, mid - 1, x);
return binarySearch(arr, mid + 1, r, x);
}
return -1;
}
function printUnion(arr1, arr2, m, n) {
if (m > n) {
let tempp = arr1;
arr1 = arr2;
arr2 = tempp;
let temp = m;
m = n;
n = temp;
}
let ans = [];
arr1.sort((a, b) => a - b);
for (let i = 0; i < m; i++)
ans.push(arr1[i]);
for (let i = 0; i < n; i++) {
if (binarySearch(arr1, 0, m - 1, arr2[i]) == -1) {
ans.push(arr2[i]);
}
}
console.log(ans)
}
function printIntersection(arr1, arr2, m, n) {
if (m > n) {
let tempp = arr1;
arr1 = arr2;
arr2 = tempp;
let temp = m;
m = n;
n = temp;
}
arr1.sort((a, b) => a - b);
let ans = [];
for (let i = 0; i < n; i++) {
if (binarySearch(arr1, 0, m - 1, arr2[i]) != -1) {
ans.push(arr2[i]);
}
}
console.log(ans)
}
let arr1 = [7, 1, 5, 2, 3, 6];
let arr2 = [3, 8, 6, 20, 7];
let m = arr1.length;
let n = arr2.length;
console.log( "Union of two arrays is" );
printUnion(arr1, arr2, m, n);
console.log( "Intersection of two arrays is" );
printIntersection(arr1, arr2, m, n);
|
Output
Union of two arrays is
[
3, 6, 7, 8,
20, 1, 5, 2
]
Intersection of two arrays is
[ 7, 3, 6 ]
Time Complexity: O(max(m*log(m), n*log(n)) + min(m, n) )
Auxiliary Space: O(1)
Without using hashing or any predefined library like sets or maps and works even for both repeated and distant elements
First of all, we sort both arrays and proceed as below:
Union
- Iterate in a while loop until any one array is finished.
- In each iteration, we look for smaller in both arrays and we print it and increment its pointer only if it is not the same as the last element printed in union.
- After we finish, while loop iterate the remaining two arrays in a similar way as above and print the union.
Intersection
- Iterate in a while loop till any of the one array is finished.
- In each iteration, we look for the smaller of the two elements from both the array and increase its pointer because it will not be in the other list, hence not part of the intersection.
- For an intersection, if both the elements are equal we print it and increment both pointers only if it is not the same as the last element printed in an intersection.
Example: This example describes the union & intersection of 2 unsorted Arrays.
Javascript
function Union(a, b, n, m) {
let result = new Array(n + m);
let index = 0;
let left = 0, right = 0;
while (left < n && right < m) {
if (a[left] < b[right]) {
if (index != 0
&& a[left] == result[index - 1]) {
left++;
}
else {
result[index] = a[left];
left++;
index++;
}
}
else {
if (index != 0
&& b[right] == result[index - 1]) {
right++;
}
else {
result[index] = b[right];
right++;
index++;
}
}
}
while (left < n) {
if (index != 0 && a[left] == result[index - 1]) {
left++;
}
else {
result[index] = a[left];
left++;
index++;
}
}
while (right < m) {
if (index != 0 && b[right] == result[index - 1]) {
right++;
}
else {
result[index] = b[right];
right++;
index++;
}
}
let ans = [];
console.log( "Union: " );
for (let k = 0; k < index; k++) { ans.push(result[k]); }
console.log(ans)
}
function intersection(a, b, n, m) {
let i = 0, j = 0, k = 0;
let result = new Array(n + m);
while (i < n && j < m) {
if (a[i] < b[j])
i++;
else if (a[i] > b[j])
j++;
else {
if (k != 0 && a[i] == result[k - 1]) {
i++;
j++;
}
else {
result[k] = a[i];
i++;
j++;
k++;
}
}
}
let ans = [];
console.log( "Intersection: " );
for (let x = 0; x < k; x++) { ans.push(result[x]); }
console.log(ans)
}
let a = [1, 3, 2, 3, 3, 4, 5, 5, 6];
let b = [3, 3, 5];
let n = a.length;
let m = b.length;
a.sort();
b.sort();
Union(a, b, n, m);
intersection(a, b, n, m);
|
Output
Union:
[ 1, 2, 3, 4, 5, 6 ]
Intersection:
[ 3, 5 ]
Kind of hashing technique without using any predefined JavaScript Collections
- Initialize the array with a size of m+n
- Fill the first array value in a resultant array by doing hashing(to find the appropriate position).
- Repeat for the second array.
- While doing hashing if a collision happens increment the position in a recursive way.
Example: This example describes the union & intersection of 2 unsorted Arrays.
Javascript
function printUnion(arr1, arr2, n1, n2) {
let s = new Set();
for (let i = 0; i < n1; i++) {
s.add(arr1[i]);
}
for (let i = 0; i < n2; i++) {
s.add(arr2[i]);
}
let ans = [];
console.log( "Union:" );
for (let itr of s)
ans.push(itr);
console.log(ans);
}
function printIntersection(arr1, arr2, n1, n2) {
let s = new Set();
let ans = [];
for (let i = 0; i < n1; i++) {
s.add(arr1[i]);
}
console.log( "Intersection:" );
for (let i = 0; i < n2; i++) {
if (s.has(arr2[i])) {
ans.push(arr2[i]);
}
}
console.log(ans);
}
let arr1 = [7, 1, 5, 2, 3, 6];
let arr2 = [3, 8, 6, 20, 7];
let n1 = arr1.length;
let n2 = arr2.length;
printUnion(arr1, arr2, n1, n2);
printIntersection(arr1, arr2, n1, n2);
|
Output
Union:
[
7, 1, 5, 2,
3, 6, 8, 20
]
Intersection:
[ 3, 6, 7 ]
Time complexity: for union is O(n1 + n2), and for intersection is O(n1 + n2).
Space complexity: for union is O(n1 + n2), and for intersection is O(min(n1, n2)).
Share your thoughts in the comments
Please Login to comment...