Union and Intersection of Two Sorted Arrays - Complete Tutorial

Union of two arrays is an array having all distinct elements that are present in either array whereas Intersection of two arrays is an array containing distinct common elements between the two arrays. In this post, we will discuss about Union and Intersection of sorted arrays.

To know about union and intersection of unsorted input arrays, please refer to Union and Intersection of Two Unsorted Arrays – Complete Tutorial.

Union of Two Sorted Arrays

Union of two sorted arrays combines all unique elements from both arrays into a single sorted array. There are several methods to find the Union of two sorted arrays based on whether the input arrays contain duplicate elements or not:

1. Union with Duplicates: When the sorted input arrays may contain duplicate elements.
2. Union with Distinct Elements: When the sorted input arrays consist of distinct elements only.

1. Union with Duplicates

We are given two sorted arrays a[] and b[] and the task is to return union of both the arrays in sorted order. Union of two arrays is an array having all distinct elements that are present in either array. The input arrays may contain duplicates.

Examples:

Input: a[] = {1, 1, 2, 2, 2, 4}, b[] = {2, 2, 4, 4}
Output: {1, 2, 4}
Explanation: 1, 2 and 4 are the distinct elements present in either array.

Input: a[] = {3, 5, 10, 10, 10, 15, 15, 20}, b[] = {5, 10, 10, 15, 30}
Output: {3, 5, 10, 15, 20, 30}
Explanation: 3, 5, 10, 15, 20 and 30 are the distinct elements present in either array.

The naive approach is to traverse both the arrays and for each element, check if the element is present in the result or not. If not, then add this element to the result.

The expected approach is to use merge step in merge sort. Maintain two pointers to traverse both arrays simultaneously. While traversing, if the elements are equal, then add one of them and move both pointers and if they are unequal, add the smaller element to the union and move the corresponding pointer. To avoid duplicates, skip the current element if it is same as the previous one.

To know more about the implementation, please refer to Union of Two Sorted Arrays.

2. Union with Distinct Elements

We are given two sorted arrays a[] and b[] having distinct elements only and the task is to return union of both the arrays in sorted order.

Examples:

Input: a[] = {1, 2, 3}, b[] = {2, 5, 7}
Output: {1, 2, 3, 5, 7}
Explanation: 1, 2, 3, 5 and 7 are the distinct elements present in either array.

Input: a[] = {2, 4, 5}, b[] = {1, 2, 3, 4, 5}
Output: {1, 2, 3, 4, 5}
Explanation: 1, 2, 3, 4 and 5 are the distinct elements present in either array.

The naive approach is to add all elements from the first array to result array. Then, iterate through the second array and add its elements to the result only if they were not present in a[]. Finally, sort the result array.

The expected approach is to use merge step in merge sort. Maintain two pointers to traverse both arrays simultaneously. While traversing, if the elements are equal, then add one of them and move both pointers and if they are unequal, add the smaller element to the union and move the corresponding pointer.

To know more about the implementation, please refer to Union of Two Sorted Arrays with Distinct Elements.

Intersection of Two Sorted Arrays

Intersection of two sorted arrays combines all unique elements that are common to both arrays into a single sorted array. There are several methods to find the Intersection of two sorted arrays based on whether the input arrays contain duplicate elements or not:

1. Intersection with Duplicates: When the sorted input arrays may contain duplicate elements.
2. Intersection with Distinct Elements: When the sorted input arrays consist of distinct elements only.

1. Intersection with Duplicates

We are given two sorted arrays a[] and b[] and the task is to return intersection of both the arrays in sorted order. Intersection of two arrays is an array having all common elements in both the arrays. The input arrays may contain duplicates.

Examples:

Input: a[] = {1, 1, 2, 2, 2, 4}, b[] = {2, 2, 4, 4}
Output: {2, 4}
Explanation: 2 and 4 are only common elements in both the arrays.

Input: a[] = {1, 2}, b[] = {3, 4}
Output: {}
Explanation: No common elements.

The naive approach is to traverse on array a[] and for each element in a[], check if it is in b[]. If Yes, then add it to the result and do not move further in b[] to avoid duplicates. To avoid duplicates in a[], skip if the current element is same as the previous element.

The expected approach is to use merge step of merge sort and maintain two pointers to traverse both arrays. While traversing, if the elements are equal, then add one of them and move both pointers and if they are unequal, skip the smaller one and move the corresponding pointer. While traversing, we avoid duplicates in a[]. We do not need to do it for b[] because once we have a match, we move ahead in a[] and b[] both.

To know more about the implementation, please refer to Intersection of Two Sorted Arrays.

2. Intersection with Distinct Elements

We are given two sorted arrays a[] and b[] having distinct elements and the task is to return intersection of both the arrays in sorted order. Intersection of two arrays is an array having all common elements in both the arrays.

Examples:

Input: a[] = { 1, 2, 4, 5, 6 }, b[] = { 2, 4, 7, 9 }
Output: { 2, 4 }
Explanation: The common elements in both arrays are 2 and 4.

Input: a[] = { 2, 3, 4, 5 } , b[] = { 1, 7 }
Output: { }
Explanation: There are no common elements in array a[] and b[].

The naive approach is to traverse the first array a[] and for each element from a[], check whether it is present in array b[]. If present then add this element to result array.

The expected approach is to use merge step of merge sort and maintain two pointers to traverse both arrays simultaneously. While traversing, if the elements are equal, then add one of them and move both pointers forward and if they are unequal, skip the smaller one and move the corresponding pointer forward.

To know more about the implementation, please refer to Intersection of Two Sorted Arrays with Distinct Elements.

Conclusion

Finding the union and intersection of two sorted arrays can be efficiently achieved using the merge step of the merge sort algorithm.

For the union of arrays, whether the input arrays contain duplicates or consist of distinct elements, maintaining two pointers allows us to efficiently combine all unique elements from both arrays into a single sorted result. Similarly, for the intersection of arrays, the same two pointers help to find the common elements while handling the duplicates.