Open In App

Find relative complement of two sorted arrays

Last Updated : 02 Dec, 2023
Improve
Improve
Like Article
Like
Save
Share
Report

Given two sorted arrays arr1 and arr2 of size m and n respectively. We need to find relative complement of two array i.e, arr1 – arr2 which means that we need to find all those elements which are present in arr1 but not in arr2.

Examples: 

Input : arr1[] = {3, 6, 10, 12, 15}
arr2[] = {1, 3, 5, 10, 16}
Output : 6 12 15
The elements 6, 12 and 15 are present
in arr[], but not present in arr2[]

Input : arr1[] = {10, 20, 36, 59}
arr2[] = {5, 10, 15, 59}
Output : 20 36
  1. Take two pointers i and j which traverse through arr1 and arr2 respectively. 
  2. If arr1[i] element is smaller than arr2[j] element print this element and increment i. 
  3. If arr1 element is greater than arr2[j] element then increment j. 
  4. otherwise increment i and j.  

Implementation:

C++




// CPP program to find all those
// elements of arr1[] that are not
// present in arr2[]
#include <iostream>
using namespace std;
 
void relativeComplement(int arr1[], int arr2[],
                               int n, int m) {
 
  int i = 0, j = 0;
  while (i < n && j < m) {
 
    // If current element in arr2[] is
    // greater, then arr1[i] can't be
    // present in arr2[j..m-1]
    if (arr1[i] < arr2[j]) {
      cout << arr1[i] << " ";
      i++;
 
    // Skipping smaller elements of
    // arr2[]
    } else if (arr1[i] > arr2[j]) {
      j++;
 
    // Equal elements found (skipping
    // in both arrays)
    } else if (arr1[i] == arr2[j]) {
      i++;
      j++;
    }
  }
 
  // Printing remaining elements of
  // arr1[]
  while (i < n)
    cout << arr1[i] << " "
}
 
// Driver code
int main() {
  int arr1[] = {3, 6, 10, 12, 15};
  int arr2[] = {1, 3, 5, 10, 16};
  int n = sizeof(arr1) / sizeof(arr1[0]);
  int m = sizeof(arr2) / sizeof(arr2[0]);
  relativeComplement(arr1, arr2, n, m);
  return 0;
}


Java




// Java program to find all those
// elements of arr1[] that are not
// present in arr2[]
 
class GFG
{
    static void relativeComplement(int arr1[], int arr2[],
                                             int n, int m)
    {
     
        int i = 0, j = 0;
        while (i < n && j < m)
        {
         
            // If current element in arr2[] is
            // greater, then arr1[i] can't be
            // present in arr2[j..m-1]
            if (arr1[i] < arr2[j])
            {
                System.out.print(arr1[i] + " ");
                i++;
         
            // Skipping smaller elements of
            // arr2[]
            } else if (arr1[i] > arr2[j])
            {
                j++;
         
            // Equal elements found (skipping
            // in both arrays)
            }
            else if (arr1[i] == arr2[j])
            {
                i++;
                j++;
            }
        }
         
        // Printing remaining elements of
        // arr1[]
        while (i < n){
            System.out.print(arr1[i] + " ");
            i++;
        }   
    }
     
    // Driver code
    public static void main (String[] args)
    {
        int arr1[] = {3, 6, 10, 12, 15};
        int arr2[] = {1, 3, 5, 10, 16};
        int n = arr1.length;
        int m = arr2.length;
        relativeComplement(arr1, arr2, n, m);
     }
}
 
// This code is contributed by Anant Agarwal.


Python3




# Python program to find all those
# elements of arr1[] that are not
# present in arr2[]
 
def relativeComplement(arr1, arr2, n, m):
  
    i = 0
    j = 0
    while (i < n and j < m):
  
        # If current element in arr2[] is
        # greater, then arr1[i] can't be
        # present in arr2[j..m-1]
        if (arr1[i] < arr2[j]):
            print(arr1[i] , " ", end="")
            i += 1
  
            # Skipping smaller elements of
            # arr2[]
        elif (arr1[i] > arr2[j]):
            j += 1
  
            # Equal elements found (skipping
            # in both arrays)
        elif (arr1[i] == arr2[j]):
            i += 1
            j += 1
     
    # Printing remaining elements of
    # arr1[]
    while (i < n):
        print(arr1[i] , " ", end="")
  
# Driver code
arr1= [3, 6, 10, 12, 15]
arr2 = [1, 3, 5, 10, 16]
n = len(arr1)
m = len(arr2)
relativeComplement(arr1, arr2, n, m)
 
# This code is contributed
# by Anant Agarwal.


C#




// C# program to find all those
// elements of arr1[] that are not
// present in arr2[]
using System;
 
namespace Complement
{
    public class GFG
    {    
                 
        static void relativeComplement(int []arr1, int []arr2,
                                                   int n, int m)
        {
     
        int i = 0, j = 0;
        while (i < n && j < m)
        {
         
            // If current element in arr2[] is
            // greater, then arr1[i] can't be
            // present in arr2[j..m-1]
            if (arr1[i] < arr2[j])
            {
                Console.Write(arr1[i] + " ");
                i++;
         
            // Skipping smaller elements of
            // arr2[]
            } else if (arr1[i] > arr2[j])
            {
                j++;
         
            // Equal elements found (skipping
            // in both arrays)
            }
            else if (arr1[i] == arr2[j])
            {
                i++;
                j++;
            }
        }
         
        // Printing remaining elements of
        // arr1[]
        while (i < n)
            Console.Write(arr1[i] + " ");
    }
     
    // Driver code
    public static void Main()
    {
        int []arr1 = {3, 6, 10, 12, 15};
        int []arr2 = {1, 3, 5, 10, 16};
        int n = arr1.Length;
        int m = arr2.Length;
        relativeComplement(arr1,arr2, n, m);
    }
    }
}
 
// This code is contributed by Sam007


Javascript




<script>
// JavaScript program to find all those
// elements of arr1[] that are not
// present in arr2[]
    function relativeComplement(arr1, arr2,
                                       n, m)
    {
       
        let i = 0, j = 0;
        while (i < n && j < m)
        {
           
            // If current element in arr2[] is
            // greater, then arr1[i] can't be
            // present in arr2[j..m-1]
            if (arr1[i] < arr2[j])
            {
                document.write(arr1[i] + " ");
                i++;
           
            // Skipping smaller elements of
            // arr2[]
            } else if (arr1[i] > arr2[j])
            {
                j++;
           
            // Equal elements found (skipping
            // in both arrays)
            }
            else if (arr1[i] == arr2[j])
            {
                i++;
                j++;
            }
        }
           
        // Printing remaining elements of
        // arr1[]
        while (i < n)
            document.write(arr1[i] + " ");
    }
   
// Driver Code
        let arr1 = [3, 6, 10, 12, 15];
        let arr2 = [1, 3, 5, 10, 16];
        let n = arr1.length;
        let m = arr2.length;
        relativeComplement(arr1, arr2, n, m);
 
// This code is contributed by splevel62.
</script>


PHP




<?php
// PHP program to find all those
// elements of arr1[] that are not
// present in arr2[]
 
function relativeComplement($arr1, $arr2,
                                 $n, $m)
{
 
    $i = 0; $j = 0;
    while ($i < $n && $j < $m)
    {
 
        // If current element in arr2[] is
        // greater, then arr1[i] can't be
        // present in arr2[j..m-1]
        if ($arr1[$i] < $arr2[$j])
        {
            echo $arr1[$i] , " ";
            $i++;
         
            // Skipping smaller elements of
            // arr2[]
        }
        else if ($arr1[$i] > $arr2[$j])
        {
            $j++;
         
            // Equal elements found (skipping
            // in both arrays)
        }
        else if ($arr1[$i] == $arr2[$j])
        {
            $i++;
            $j++;
        }
    }
 
    // Printing remaining elements of
    // arr1[]
    while ($i < $n)
        echo $arr1[$i] , " ";
}
 
// Driver code
{
    $arr1 = array(3, 6, 10, 12, 15);
    $arr2 = array(1, 3, 5, 10, 16);
    $n = sizeof($arr1) / sizeof($arr1[0]);
    $m = sizeof($arr2) / sizeof($arr2[0]);
    relativeComplement($arr1, $arr2, $n, $m);
    return 0;
}
 
// This code is contributed by nitin mittal
?>


Output

6 12 15 






Time Complexity : O(m + n)
Auxiliary Space: O(1)

Another Approach:

Using an unordered_set we can do the same by following these steps.

  • store all the elements of the second array in the set.
  • Now traverse the second array and for each element check whether it is present in the set or not
  • If the element is not present in the map we add it to our answer array.

Below is the implementation for the same

C++




#include <iostream>
#include <unordered_set>
#include <vector>
using namespace std;
 
void relativeComplement(int arr1[], int arr2[], int n,
                        int m)
{
    // initializing our set
    unordered_set<int> s;
    // initialixing our ans vector
    vector<int> ans;
    // storing elements of the second array in the set
    for (int i = 0; i < m; i++)
        s.insert(arr2[i]);
    // traversing the second array
    for (int i = 0; i < n; i++) {
        // if the element is not found in the set add it to
        // the ans vector
        if (s.find(arr1[i]) == s.end())
            ans.push_back(arr1[i]);
    }
    // printing the answer vector.
    for (auto x : ans)
        cout << x << " ";
}
 
int main()
{
    int arr1[] = { 3, 6, 10, 12, 15 };
    int arr2[] = { 1, 3, 5, 10, 16 };
    int n = sizeof(arr1) / sizeof(arr1[0]);
    int m = sizeof(arr2) / sizeof(arr2[0]);
    relativeComplement(arr1, arr2, n, m);
    return 0;
}


Java




import java.io.*;
import java.util.*;
 
public class GFG {
    public static void relativeComplement(int[] arr1, int[] arr2, int n, int m) {
        // Initializing our set
        HashSet<Integer> set = new HashSet<>();
        // Initializing our answer ArrayList
        ArrayList<Integer> ans = new ArrayList<>();
        // Storing elements of the second array in the set
        for (int i = 0; i < m; i++) {
            set.add(arr2[i]);
        }
        // Traversing the first array
        for (int i = 0; i < n; i++) {
            // If the element is not found in the set, add it to the answer ArrayList
            if (!set.contains(arr1[i])) {
                ans.add(arr1[i]);
            }
        }
        // Printing the answer ArrayList.
        for (int x : ans) {
            System.out.print(x + " ");
        }
    }
 
    public static void main(String[] args) {
        int[] arr1 = { 3, 6, 10, 12, 15 };
        int[] arr2 = { 1, 3, 5, 10, 16 };
        int n = arr1.length;
        int m = arr2.length;
        relativeComplement(arr1, arr2, n, m);
    }
}


Python3




def relative_complement(arr1, arr2):
    # initializing our set
    s = set()
    # initializing our ans list
    ans = []
     
    # storing elements of the second array in the set
    for num in arr2:
        s.add(num)
     
    # traversing the first array
    for num in arr1:
        # if the element is not found in the set, add it to the ans list
        if num not in s:
            ans.append(num)
     
    # printing the answer list
    for x in ans:
        print(x, end=" ")
 
if __name__ == "__main__":
    arr1 = [3, 6, 10, 12, 15]
    arr2 = [1, 3, 5, 10, 16]
     
    relative_complement(arr1, arr2)


C#




using System;
using System.Collections.Generic;
 
class Program
{
    // Function to find the relative complement of two integer arrays
    static void RelativeComplement(int[] arr1, int[] arr2)
    {
        // Initializing a HashSet to store elements of the second array
        HashSet<int> set = new HashSet<int>();
         
        // Initializing a List to store the result
        List<int> result = new List<int>();
         
        // Storing elements of the second array in the HashSet
        foreach (int num in arr2)
        {
            set.Add(num);
        }
         
        // Traversing the first array
        foreach (int num in arr1)
        {
            // If the element is not found in the HashSet, add it to the result list
            if (!set.Contains(num))
            {
                result.Add(num);
            }
        }
         
        // Printing the result
        foreach (int num in result)
        {
            Console.Write(num + " ");
        }
    }
 
    static void Main()
    {
        int[] arr1 = { 3, 6, 10, 12, 15 };
        int[] arr2 = { 1, 3, 5, 10, 16 };
         
        // Call the function to find the relative complement
        RelativeComplement(arr1, arr2);
    }
}


Javascript




function relativeComplement(arr1, arr2) {
    // initializing our set
    let s = new Set();
    // initializing our ans array
    let ans = [];
 
    // storing elements of the second array in the set
    for (let i = 0; i < arr2.length; i++) {
        s.add(arr2[i]);
    }
 
    // traversing the first array
    for (let i = 0; i < arr1.length; i++) {
        // if the element is not found in the set, add it to the ans array
        if (!s.has(arr1[i])) {
            ans.push(arr1[i]);
        }
    }
 
    // printing the answer array.
    console.log(ans.join(' '));
}
 
// Driver Code
let arr1 = [3, 6, 10, 12, 15];
let arr2 = [1, 3, 5, 10, 16];
 
relativeComplement(arr1, arr2);


Output:

6 12 15 

Time Complexity: O(G) where G is the size of the bigger array.
Auxiliary Space: O(m), we are storing elements of the second array in the set.



Like Article
Suggest improvement
Previous
Next
Share your thoughts in the comments

Similar Reads