Union and Intersection Of Two Sorted Arrays In Java

The union and intersection of two sorted arrays are fundamental operations in computer science and data analysis. In Java, these operations can be performed efficiently on two sorted arrays by utilizing their inherent order. The union of two arrays is the set of all elements that are in either array, while the intersection is the set of all elements that are common to both arrays. These operations are commonly used in a wide range of applications, including database management, information retrieval, and statistics.

Union

In Java, the union of two sorted arrays can be obtained by merging the two arrays and removing duplicates. It is a common operation in programming and is often used in tasks such as merging two lists or finding the common elements between two lists. The union operation combines the elements of both arrays into a new array that contains all unique elements from both arrays.

Given two sorted arrays, find their union and Intersection.

Example 1:

Input:

arr1[] = {2, 5, 6}

arr2[] = {4, 6, 8, 10}

Output:

Union: {2, 4, 5, 6, 8, 10}

Intersection : {6}

Example 2:

Input:

arr1[] = {2, 3, 6, 7, 9}

arr2[] = {1, 3, 5, 6, 8}

Output:

Union: {1, 2, 3, 5, 6, 7, 8, 9}

Intersection : {3, 6}

Example 3:

Input:

arr1[] = {4, 6, 8, 10}

arr2[] = {1, 2, 4, 5, 8}

Output:

Union: {1, 2, 4, 5, 6, 8, 10}

Intersection : {4, 8}

Approach: Union of arrays arr1[] and arr2[]

The union of two arrays, arr1[] and arr2[], is a new array that contains all distinct elements from both arrays. To obtain the union of two sorted arrays, we can use a two-pointer approach to traverse the arrays and add elements to the union array.

Algorithm

Create an empty ArrayList to store the result.
Initialize two pointers, i and j, to the start of arr1 and arr2, respectively.
Iterate until pointers i and j are less than their respective array lengths.
If arr1[i] is less than arr2[j], add arr1[i] to the result ArrayList and Increment i.
If arr1[i] is greater than arr2[j], add arr2[j] to the result ArrayList and increment j.
If arr1[i] is equal to arr2[j], add arr1[i] to the result ArrayList and Increment both i and j.
If there are remaining elements in arr1 or arr2, add them to the result ArrayList.
Convert the result ArrayList to an array of integers and return i

Implementation

Filename: ArrayUnion.java

public class ArrayUnion {
    public static void main(String[] args) {
        int[] arr1 = {1, 3, 5, 7};
        int[] arr2 = {2, 4, 6, 8};
        
        int m = arr1.length;
        int n = arr2.length;
        
        System.out.print("Union of two arrays: ");
        printUnion(arr1, arr2, m, n);
    }
    
    public static void printUnion(int[] arr1, int[] arr2, int m, int n) {
        int i = 0, j = 0;
        
        //Loop through both arrays until one of them is exhausted
        while (i < m && j < n) {
            if (arr1[i] < arr2[j]) {
                // If the element at i is smaller, print it and move to the next element in arr1
                System.out.print(arr1[i++] + " ");
            } else if (arr1[i] > arr2[j]) {
                // If the element at j is smaller, print it and move to the next element in arr2
                System.out.print(arr2[j++] + " ");
            } else {
                // If the elements are equal, print one of them and move both pointers to the next element
                System.out.print(arr1[i++] + " ");
                j++;
            }
        }
        
        // If there are any remaining elements in arr1, print them
        while (i < m) {
            System.out.print(arr1[i++] + " ");
        }
        
        // If there are any remaining elements in arr2, print them
        while (j < n) {
            System.out.print(arr2[j++] + " ");
        }
    }
}

Output:

Union of two arrays: 1 2 3 4 5 6 7 8

Complexity Analysis:

The time complexity of the code is O(m+n), where m and n are the lengths of the two input arrays. It is because the while loop that iterates through both arrays has a maximum of m+n iterations, as each iteration increments either the i or j pointer until one of the arrays is fully traversed.

The space complexity is also O(m+n), as the only additional space used is for the variables i, j, m, and n and the printed Output.

Approach: Using Set

The approach using a Set is a simple and efficient way to find the union of two sorted arrays. By inserting all the elements from both arrays into a Set, duplicates are automatically removed, and the resulting Set contains all the unique elements from both arrays.

Filename: UnionOfSortedArrays.java

import java.util.*;

public class UnionOfSortedArrays {

    public static void main(String[] args) {
        int[] arr1 = {1, 3, 3, 5, 7, 7, 9};
        int[] arr2 = {2, 4, 6, 8, 8, 8, 10};
        int m = arr1.length;
        int n = arr2.length;
        TreeSet<Integer> set = new TreeSet<>();

        // Add all elements of arr1 to the TreeSet
        for (int i = 0; i < m; i++) {
            set.add(arr1[i]);
        }

        // Add all elements of arr2 to the TreeSet
        for (int i = 0; i < n; i++) {
            set.add(arr2[i]);
        }

        // Traverse the TreeSet and print the elements
        Iterator<Integer> iterator = set.iterator();
        while (iterator.hasNext()) {
            System.out.print(iterator.next() + " ");
        }
    }
}

Output:

1 2 3 4 5 6 7 8 9 10

Complexity Analysis: The time complexity of the given code is O(mlog(m) + nlog(n)), where m and n are the lengths of the input arrays arr1 and arr2. The time complexity is improved by adding all the elements of both arrays to a TreeSet, which is implemented using a self-balancing binary search tree. The add() operation on a TreeSet has a time complexity of O(log(n)), where n is the size of the Set.

The space complexity of the code is O(m+n), as we are using a TreeSet to store the unique elements of both arrays, and the size of the Set can be at most m+n.

Approach: Using HashMap

The union of two sorted arrays can be implemented in Java using a HashMap to efficiently store and retrieve the elements of the arrays while removing duplicates. The approach involves iterating through the arrays using two pointers, adding the elements to the HashMap, and returning the keys of the HashMap as the union of the two arrays.

Filename: UnionOfSortedArrays.java

import java.util.HashMap;
import java.util.ArrayList;

public class UnionOfSortedArrays {

    public static ArrayList<Integer> union(int[] array1, int[] array2) {
        HashMap<Integer, Integer> map = new HashMap<>();
        ArrayList<Integer> result = new ArrayList<>();
        int i = 0, j = 0;

        //Loop through the two arrays simultaneously using two pointers, i and j
        while (i < array1.length && j < array2.length) {
            // Compare the elements at array1[i] and array2[j]
            if (array1[i] == array2[j]) {
                // If they are equal, add the element to the HashMap with a frequency of 2 and increment both pointers i and j
                map.put(array1[i], 2);
                i++;
                j++;
            } else if (array1[i] < array2[j]) {
                // If array1[i] is less than array2[j], add array1[i] to the HashMap and increment i
                map.put(array1[i], 1);
                i++;
            } else {
                // If array1[i] is greater than array2[j], add array2[j] to the HashMap and increment j
                map.put(array2[j], 1);
                j++;
            }
        }

        // If there are any remaining elements in array1 or array2, add them to the HashMap
        while (i < array1.length) {
            map.put(array1[i], 1);
            i++;
        }

        while (j < array2.length) {
            map.put(array2[j], 1);
            j++;
        }

        // Return the keys of the HashMap as the union of the two arrays
        for (int key : map.keySet()) {
            result.add(key);
        }

        return result;
    }

    public static void main(String[] args) {
        int[] array1 = {1, 3, 4, 5, 7};
        int[] array2 = {2, 3, 5, 6};
        ArrayList<Integer> union = union(array1, array2);
        System.out.println(union);
    }
}

Output:

[1, 2, 3, 4, 5, 6, 7]

Complexity Analysis: The algorithm's time complexity is O(m+n), where m and n are the lengths of the two input arrays. The time complexity of adding an element to a HashMap and retrieving its keys is constant time, O(1), which contributes to the overall efficiency of the algorithm as it loops through both arrays only once

The space complexity of the algorithm is O(m+n) as well since the size of the HashMap and the ArrayList will be, at most, the size of the two input arrays combined.Intersection of arrays arr1[] and arr2[]

Intersection

Intersection is a common set operation in computer science that involves finding the common elements between two sets. In Java, we can find the intersection of two arrays by iterating through each element of one array and checking if it exists in the other array. The resulting array will contain the elements that are present in both arrays.

Approach: Intersection of arrays arr1[] and arr2[]

Algorithm

To find the Intersection of two arrays, arr1, and arr2, we can follow these steps:

Initialize two pointers, i and j, at the start of arr1 and arr2, respectively.
Iterate over both arrays using the two-pointers.
- If arr1[i] is equal to arr2[j], add the element to the intersection list, and increment both pointers i and j.
- Otherwise, if arr1[i] is less than arr2[j], Increment i.
- Otherwise, if arr1[i] is greater than arr2[j], increment j.
Return the intersection list.

Implementation

Filename: IntersectionOfArrays.java

// Import necessary classes
import java.util.ArrayList;
import java.util.Arrays;

// Define a class named IntersectionOfArrays
public class IntersectionOfArrays {

// Define a static method named Intersection that takes two integer arrays as input and returns an ArrayList of integers
public static ArrayList<Integer> intersection(int[] arr1, int[] arr2) {
    // Initialize an ArrayList to hold the Intersection of the two arrays
    ArrayList<Integer> result = new ArrayList<>();
    // Initialize two pointers, i and j, to the start of the two arrays
    int i = 0, j = 0;

    //Loop through both arrays simultaneously using the pointers i and j
    while (i < arr1.length && j < arr2.length) {
        // Compare the elements at indices i and j of the two arrays
        if (arr1[i] == arr2[j]) {
            // If they are equal, add the element to the result ArrayList, and increment both pointers i and j
            result.add(arr1[i]);
            i++;
            j++;
        } else if (arr1[i] < arr2[j]) {
            // If the element at index i of arr1 is less than the element at index j of arr2, increment i
            i++;
        } else {
            // If the element at index j of arr2 is less than the element at index i of arr1, increment j
            j++;
        }
    }

    // Return the resulting ArrayList containing the Intersection of the two input arrays
    return result;
}

// Define the main Method to test the intersection method
public static void main(String[] args) {
    int[] arr1 = {1, 2, 3, 4, 5};
    int[] arr2 = {3, 4, 5, 6, 7};
    ArrayList<Integer> intersection = intersection(arr1, arr2);
    System.out.println(intersection);
}
}

Output:

[3, 4, 5]

Complexity Analysis: The time complexity of the program is O(m + n), and space complexity of program is O(min(m, n).

Approach: Using Tree Set

The main goal of this approach is to create a data structure using a tree set that can hold all the distinct elements found in arri[]. Then compare the elements arr2[] with the tree set and check if that is considered in the intersection to avoid duplicates.

Filename: TreeSetDemo.java

import java.util.*;

public class TreeSetDemo {
    
    //Method to find the Intersection of two arrays
    public static int[] findIntersection(int[] arr1, int[] arr2) {
        // create two sets to store the arrays
        Set<Integer> set1 = new TreeSet<>();
        Set<Integer> set2 = new TreeSet<>();
        // add elements of arr1 to set1
        for (int i = 0; i < arr1.length; i++) {
            set1.add(arr1[i]);
        }
        // add elements of arr2 to set2
        for (int i = 0; i < arr2.length; i++) {
            set2.add(arr2[i]);
        }
        // create a set to store the Intersection
        Set<Integer> intersectionSet = new HashSet<>(set1);
        //Retain only the elements present in both sets
        intersectionSet.retainAll(set2);
        // convert Intersection set to array and return
        int[] intersection = new int[intersectionSet.size()];
        int i = 0;
        for (int num : intersectionSet) {
            intersection[i++] = num;
        }
        return intersection;
    }
    
    public static void main(String[] args) {
        // sample input arrays
        int[] arr1 = {1, 2, 2, 3, 4, 5};
        int[] arr2 = {2, 3, 3, 4, 5, 6};
        //Call the findIntersection method and store the result in the intersection array
        int[] intersection = findIntersection(arr1, arr2);
        // print intersection array
        for (int i = 0; i < intersection.length; i++) {
            System.out.print(intersection[i] + " ");
        }
    }
}

Output:

2 3 4 5

Complexity Analysis: The time complexity of the findIntersection Method is O(nlogn) because it involves adding n elements to two TreeSets, which takes O(nlogn) time complexity, and then finding the Intersection using retainAll Method, which takes O(n) time complexity on average.

The overall space complexity of the findIntersection Method is O(n) because it involves creating three sets of size n, which takes O(n) space complexity.

Next TopicVector Operations Java

← prev next →