Related Articles
Union and Intersection of two sorted arrays
• Difficulty Level : Easy
• Last Updated : 30 Oct, 2020

Given two sorted arrays, find their union and intersection.
Example:

```Input : arr1[] = {1, 3, 4, 5, 7}
arr2[] = {2, 3, 5, 6}
Output : Union : {1, 2, 3, 4, 5, 6, 7}
Intersection : {3, 5}

Input : arr1[] = {2, 5, 6}
arr2[] = {4, 6, 8, 10}
Output : Union : {2, 4, 5, 6, 8, 10}
Intersection : {6}
```

## We strongly recommend that you click here and practice it, before moving on to the solution.

Union of arrays arr1[] and arr2[]

To find union of two sorted arrays, follow the following merge procedure :

1) Use two index variables i and j, initial values i = 0, j = 0
2) If arr1[i] is smaller than arr2[j] then print arr1[i] and increment i.
3) If arr1[i] is greater than arr2[j] then print arr2[j] and increment j.
4) If both are same then print any of them and increment both i and j.
5) Print remaining elements of the larger array.

Below is the implementation of the above approach :

## C++

 `// C++ program to find union of ` `// two sorted arrays ` `#include ` `using` `namespace` `std; ` ` `  `/* Function prints union of arr1[] and arr2[] ` `   ``m is the number of elements in arr1[] ` `   ``n is the number of elements in arr2[] */` `int` `printUnion(``int` `arr1[], ``int` `arr2[], ``int` `m, ``int` `n) ` `{ ` `    ``int` `i = 0, j = 0; ` `    ``while` `(i < m && j < n) { ` `        ``if` `(arr1[i] < arr2[j]) ` `            ``cout << arr1[i++] << ``" "``; ` ` `  `        ``else` `if` `(arr2[j] < arr1[i]) ` `            ``cout << arr2[j++] << ``" "``; ` ` `  `        ``else` `{ ` `            ``cout << arr2[j++] << ``" "``; ` `            ``i++; ` `        ``} ` `    ``} ` ` `  `    ``/* Print remaining elements of the larger array */` `    ``while` `(i < m) ` `        ``cout << arr1[i++] << ``" "``; ` ` `  `    ``while` `(j < n) ` `        ``cout << arr2[j++] << ``" "``; ` `} ` ` `  `/* Driver program to test above function */` `int` `main() ` `{ ` `    ``int` `arr1[] = { 1, 2, 4, 5, 6 }; ` `    ``int` `arr2[] = { 2, 3, 5, 7 }; ` ` `  `    ``int` `m = ``sizeof``(arr1) / ``sizeof``(arr1); ` `    ``int` `n = ``sizeof``(arr2) / ``sizeof``(arr2); ` ` `  `    ``// Function calling ` `    ``printUnion(arr1, arr2, m, n); ` ` `  `    ``return` `0; ` `} `

## C

 `// C program to find union of ` `// two sorted arrays ` `#include ` ` `  `/* Function prints union of arr1[] and arr2[] ` `   ``m is the number of elements in arr1[] ` `   ``n is the number of elements in arr2[] */` `int` `printUnion(``int` `arr1[], ``int` `arr2[], ``int` `m, ``int` `n) ` `{ ` `    ``int` `i = 0, j = 0; ` `    ``while` `(i < m && j < n) { ` `        ``if` `(arr1[i] < arr2[j]) ` `            ``printf``(``" %d "``, arr1[i++]); ` `        ``else` `if` `(arr2[j] < arr1[i]) ` `            ``printf``(``" %d "``, arr2[j++]); ` `        ``else` `{ ` `            ``printf``(``" %d "``, arr2[j++]); ` `            ``i++; ` `        ``} ` `    ``} ` ` `  `    ``/* Print remaining elements of the larger array */` `    ``while` `(i < m) ` `        ``printf``(``" %d "``, arr1[i++]); ` `    ``while` `(j < n) ` `        ``printf``(``" %d "``, arr2[j++]); ` `} ` ` `  `/* Driver program to test above function */` `int` `main() ` `{ ` `    ``int` `arr1[] = { 1, 2, 4, 5, 6 }; ` `    ``int` `arr2[] = { 2, 3, 5, 7 }; ` `    ``int` `m = ``sizeof``(arr1) / ``sizeof``(arr1); ` `    ``int` `n = ``sizeof``(arr2) / ``sizeof``(arr2); ` `    ``printUnion(arr1, arr2, m, n); ` `    ``getchar``(); ` `    ``return` `0; ` `} `

## Java

 `// Java program to find union of ` `// two sorted arrays ` ` `  `class` `FindUnion { ` `    ``/* Function prints union of arr1[] and arr2[] ` `    ``m is the number of elements in arr1[] ` `    ``n is the number of elements in arr2[] */` `    ``static` `int` `printUnion(``int` `arr1[], ``int` `arr2[], ``int` `m, ``int` `n) ` `    ``{ ` `        ``int` `i = ``0``, j = ``0``; ` `        ``while` `(i < m && j < n) { ` `            ``if` `(arr1[i] < arr2[j]) ` `                ``System.out.print(arr1[i++] + ``" "``); ` `            ``else` `if` `(arr2[j] < arr1[i]) ` `                ``System.out.print(arr2[j++] + ``" "``); ` `            ``else` `{ ` `                ``System.out.print(arr2[j++] + ``" "``); ` `                ``i++; ` `            ``} ` `        ``} ` ` `  `        ``/* Print remaining elements of  ` `         ``the larger array */` `        ``while` `(i < m) ` `            ``System.out.print(arr1[i++] + ``" "``); ` `        ``while` `(j < n) ` `            ``System.out.print(arr2[j++] + ``" "``); ` ` `  `        ``return` `0``; ` `    ``} ` ` `  `    ``public` `static` `void` `main(String args[]) ` `    ``{ ` `        ``int` `arr1[] = { ``1``, ``2``, ``4``, ``5``, ``6` `}; ` `        ``int` `arr2[] = { ``2``, ``3``, ``5``, ``7` `}; ` `        ``int` `m = arr1.length; ` `        ``int` `n = arr2.length; ` `        ``printUnion(arr1, arr2, m, n); ` `    ``} ` `} `

## Python

 `# Python program to find union of ` `# two sorted arrays ` `# Function prints union of arr1[] and arr2[] ` `# m is the number of elements in arr1[] ` `# n is the number of elements in arr2[] ` `def` `printUnion(arr1, arr2, m, n): ` `    ``i, j ``=` `0``, ``0` `    ``while` `i < m ``and` `j < n: ` `        ``if` `arr1[i] < arr2[j]: ` `            ``print``(arr1[i]) ` `            ``i ``+``=` `1` `        ``elif` `arr2[j] < arr1[i]: ` `            ``print``(arr2[j]) ` `            ``j``+``=` `1` `        ``else``: ` `            ``print``(arr2[j]) ` `            ``j ``+``=` `1` `            ``i ``+``=` `1` ` `  `    ``# Print remaining elements of the larger array ` `    ``while` `i < m: ` `        ``print``(arr1[i]) ` `        ``i ``+``=` `1` ` `  `    ``while` `j < n: ` `        ``print``(arr2[j]) ` `        ``j ``+``=` `1` ` `  `# Driver program to test above function ` `arr1 ``=` `[``1``, ``2``, ``4``, ``5``, ``6``] ` `arr2 ``=` `[``2``, ``3``, ``5``, ``7``] ` `m ``=` `len``(arr1) ` `n ``=` `len``(arr2) ` `printUnion(arr1, arr2, m, n) ` ` `  `# This code is contributed by Pratik Chhajer `

## C#

 `// C# program to find union of ` `// two sorted arrays ` ` `  `using` `System; ` ` `  `class` `GFG { ` `    ``/* Function prints union of arr1[] and arr2[] ` `    ``m is the number of elements in arr1[] ` `    ``n is the number of elements in arr2[] */` `    ``static` `int` `printUnion(``int``[] arr1, ` `                          ``int``[] arr2, ``int` `m, ``int` `n) ` `    ``{ ` `        ``int` `i = 0, j = 0; ` ` `  `        ``while` `(i < m && j < n) { ` `            ``if` `(arr1[i] < arr2[j]) ` `                ``Console.Write(arr1[i++] + ``" "``); ` `            ``else` `if` `(arr2[j] < arr1[i]) ` `                ``Console.Write(arr2[j++] + ``" "``); ` `            ``else` `{ ` `                ``Console.Write(arr2[j++] + ``" "``); ` `                ``i++; ` `            ``} ` `        ``} ` ` `  `        ``/* Print remaining elements of  ` `        ``the larger array */` `        ``while` `(i < m) ` `            ``Console.Write(arr1[i++] + ``" "``); ` `        ``while` `(j < n) ` `            ``Console.Write(arr2[j++] + ``" "``); ` ` `  `        ``return` `0; ` `    ``} ` ` `  `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``int``[] arr1 = { 1, 2, 4, 5, 6 }; ` `        ``int``[] arr2 = { 2, 3, 5, 7 }; ` `        ``int` `m = arr1.Length; ` `        ``int` `n = arr2.Length; ` ` `  `        ``printUnion(arr1, arr2, m, n); ` `    ``} ` `} ` ` `  `// This code is contributed by Sam007 `

## PHP

 ` `

Output:

```1 2 3 4 5 6 7
```

Time Complexity : O(m + n)
Handling duplicates in any of the array : Above code does not handle duplicates in any of the array. To handle the duplicates, just check for every element whether adjacent elements are equal.
Below is the implementation of this approach.

## Java

 `// Java program to find union of two ` `// sorted arrays (Handling Duplicates) ` `class` `FindUnion { ` ` `  `    ``static` `void` `UnionArray(``int` `arr1[], ` `                           ``int` `arr2[]) ` `    ``{ ` `        ``// Taking max element present in either array ` `        ``int` `m = arr1[arr1.length - ``1``]; ` `        ``int` `n = arr2[arr2.length - ``1``]; ` ` `  `        ``int` `ans = ``0``; ` ` `  `        ``if` `(m > n) { ` `            ``ans = m; ` `        ``} ` `        ``else` `            ``ans = n; ` ` `  `        ``// Finding elements from 1st array ` `        ``// (non duplicates only). Using ` `        ``// another array for storing union ` `        ``// elements of both arrays ` `        ``// Assuming max element present ` `        ``// in array is not more than 10^7 ` `        ``int` `newtable[] = ``new` `int``[ans + ``1``]; ` ` `  `        ``// First element is always ` `        ``// present in final answer ` `        ``System.out.print(arr1[``0``] + ``" "``); ` ` `  `        ``// Incrementing the First element's count ` `        ``// in it's corresponding index in newtable ` `        ``++newtable[arr1[``0``]]; ` ` `  `        ``// Starting traversing the first ` `        ``// array from 1st index till last ` `        ``for` `(``int` `i = ``1``; i < arr1.length; i++) { ` `            ``// Checking whether current element ` `            ``// is not equal to it's previous element ` `            ``if` `(arr1[i] != arr1[i - ``1``]) { ` `                ``System.out.print(arr1[i] + ``" "``); ` `                ``++newtable[arr1[i]]; ` `            ``} ` `        ``} ` ` `  `        ``// Finding only non common ` `        ``// elements from 2nd array ` `        ``for` `(``int` `j = ``0``; j < arr2.length; j++) { ` `            ``// By checking whether it's already ` `            ``// present in newtable or not ` `            ``if` `(newtable[arr2[j]] == ``0``) { ` `                ``System.out.print(arr2[j] + ``" "``); ` `                ``++newtable[arr2[j]]; ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// Driver Code ` `    ``public` `static` `void` `main(String args[]) ` `    ``{ ` `        ``int` `arr1[] = { ``1``, ``2``, ``2``, ``2``, ``3` `}; ` `        ``int` `arr2[] = { ``2``, ``3``, ``4``, ``5` `}; ` ` `  `        ``UnionArray(arr1, arr2); ` `    ``} ` `} `

## Python3

 `# Python3 program to find union of two  ` `# sorted arrays (Handling Duplicates)  ` `def` `UnionArray(arr1, arr2):  ` `     `  `    ``# Taking max element present in either array  ` `    ``m ``=` `arr1[``-``1``]  ` `    ``n ``=` `arr2[``-``1``]  ` `    ``ans ``=` `0` `         `  `    ``if` `m > n:  ` `        ``ans ``=` `m  ` `    ``else``: ` `        ``ans ``=` `n  ` `         `  `    ``# Finding elements from 1st array  ` `    ``# (non duplicates only). Using  ` `    ``# another array for storing union  ` `    ``# elements of both arrays  ` `    ``# Assuming max element present  ` `    ``# in array is not more than 10 ^ 7  ` `    ``newtable ``=` `[``0``] ``*` `(ans ``+` `1``)  ` `         `  `    ``# First element is always  ` `    ``# present in final answer  ` `    ``print``(arr1[``0``], end ``=` `" "``)  ` `         `  `    ``# Incrementing the First element's count  ` `    ``# in it's corresponding index in newtable  ` `    ``newtable[arr1[``0``]] ``+``=` `1` `         `  `    ``# Starting traversing the first  ` `    ``# array from 1st index till last  ` `    ``for` `i ``in` `range``(``1``, ``len``(arr1)):  ` `         `  `        ``# Checking whether current element  ` `        ``# is not equal to it's previous element  ` `        ``if` `arr1[i] !``=` `arr1[i ``-` `1``]:  ` `             `  `            ``print``(arr1[i], end ``=` `" "``)  ` `            ``newtable[arr1[i]] ``+``=` `1` `             `  `    ``# Finding only non common  ` `    ``# elements from 2nd array          ` `    ``for` `j ``in` `range``(``0``, ``len``(arr2)):  ` `         `  `        ``# By checking whether it's already  ` `        ``# present in newtable or not  ` `        ``if` `newtable[arr2[j]] ``=``=` `0``:  ` `             `  `            ``print``(arr2[j], end ``=` `" "``)  ` `            ``newtable[arr2[j]] ``+``=` `1` `     `  `# Driver Code  ` `if` `__name__ ``=``=` `"__main__"``:  ` `     `  `    ``arr1 ``=` `[``1``, ``2``, ``2``, ``2``, ``3``] ` `    ``arr2 ``=` `[``2``, ``3``, ``4``, ``5``] ` `         `  `    ``UnionArray(arr1, arr2)  ` ` `  `# This code is contributed by Rituraj Jain `

## C#

 `// C# program to find union of two ` `// sorted arrays (Handling Duplicates) ` `using` `System; ` ` `  `class` `GFG { ` ` `  `    ``static` `void` `UnionArray(``int``[] arr1, ` `                           ``int``[] arr2) ` `    ``{ ` ` `  `        ``// Taking max element present ` `        ``// in either array ` `        ``int` `m = arr1[arr1.Length - 1]; ` `        ``int` `n = arr2[arr2.Length - 1]; ` ` `  `        ``int` `ans = 0; ` ` `  `        ``if` `(m > n) ` `            ``ans = m; ` `        ``else` `            ``ans = n; ` ` `  `        ``// Finding elements from 1st array ` `        ``// (non duplicates only). Using ` `        ``// another array for storing union ` `        ``// elements of both arrays ` `        ``// Assuming max element present ` `        ``// in array is not more than 10^7 ` `        ``int``[] newtable = ``new` `int``[ans + 1]; ` ` `  `        ``// First element is always ` `        ``// present in final answer ` `        ``Console.Write(arr1 + ``" "``); ` ` `  `        ``// Incrementing the First element's ` `        ``// count in it's corresponding ` `        ``// index in newtable ` `        ``++newtable[arr1]; ` ` `  `        ``// Starting traversing the first ` `        ``// array from 1st index till last ` `        ``for` `(``int` `i = 1; i < arr1.Length; i++) { ` `            ``// Checking whether current ` `            ``// element is not equal to ` `            ``// it's previous element ` `            ``if` `(arr1[i] != arr1[i - 1]) { ` `                ``Console.Write(arr1[i] + ``" "``); ` `                ``++newtable[arr1[i]]; ` `            ``} ` `        ``} ` ` `  `        ``// Finding only non common ` `        ``// elements from 2nd array ` `        ``for` `(``int` `j = 0; j < arr2.Length; j++) { ` `            ``// By checking whether it's already ` `            ``// present in newtable or not ` `            ``if` `(newtable[arr2[j]] == 0) { ` `                ``Console.Write(arr2[j] + ``" "``); ` `                ``++newtable[arr2[j]]; ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// Driver Code ` `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``int``[] arr1 = { 1, 2, 2, 2, 3 }; ` `        ``int``[] arr2 = { 2, 3, 4, 5 }; ` ` `  `        ``UnionArray(arr1, arr2); ` `    ``} ` `} ` ` `  `// This code is contributed by anuj_67. `

Thanks to Rajat Rawat for suggesting this solution.

Intersection of arrays arr1[] and arr2[]

To find intersection of 2 sorted arrays, follow the below approach :

1) Use two index variables i and j, initial values i = 0, j = 0
2) If arr1[i] is smaller than arr2[j] then increment i.
3) If arr1[i] is greater than arr2[j] then increment j.
4) If both are same then print any of them and increment both i and j.

Below is the implementation of the above approach :

## C++

 `// C++ program to find intersection of ` `// two sorted arrays ` `#include ` `using` `namespace` `std; ` ` `  `/* Function prints Intersection of arr1[] and arr2[] ` `m is the number of elements in arr1[] ` `n is the number of elements in arr2[] */` `int` `printIntersection(``int` `arr1[], ``int` `arr2[], ``int` `m, ``int` `n) ` `{ ` `    ``int` `i = 0, j = 0; ` `    ``while` `(i < m && j < n) { ` `        ``if` `(arr1[i] < arr2[j]) ` `            ``i++; ` `        ``else` `if` `(arr2[j] < arr1[i]) ` `            ``j++; ` `        ``else` `/* if arr1[i] == arr2[j] */` `        ``{ ` `            ``cout << arr2[j] << ``" "``; ` `            ``i++; ` `            ``j++; ` `        ``} ` `    ``} ` `} ` ` `  `/* Driver program to test above function */` `int` `main() ` `{ ` `    ``int` `arr1[] = { 1, 2, 4, 5, 6 }; ` `    ``int` `arr2[] = { 2, 3, 5, 7 }; ` ` `  `    ``int` `m = ``sizeof``(arr1) / ``sizeof``(arr1); ` `    ``int` `n = ``sizeof``(arr2) / ``sizeof``(arr2); ` ` `  `    ``// Function calling ` `    ``printIntersection(arr1, arr2, m, n); ` ` `  `    ``return` `0; ` `} `

## C

 `// C program to find intersection of ` `// two sorted arrays ` `#include ` ` `  `/* Function prints Intersection of arr1[] and arr2[] ` `   ``m is the number of elements in arr1[] ` `   ``n is the number of elements in arr2[] */` `int` `printIntersection(``int` `arr1[], ``int` `arr2[], ``int` `m, ``int` `n) ` `{ ` `    ``int` `i = 0, j = 0; ` `    ``while` `(i < m && j < n) { ` `        ``if` `(arr1[i] < arr2[j]) ` `            ``i++; ` `        ``else` `if` `(arr2[j] < arr1[i]) ` `            ``j++; ` `        ``else` `/* if arr1[i] == arr2[j] */` `        ``{ ` `            ``printf``(``" %d "``, arr2[j++]); ` `            ``i++; ` `        ``} ` `    ``} ` `} ` ` `  `/* Driver program to test above function */` `int` `main() ` `{ ` `    ``int` `arr1[] = { 1, 2, 4, 5, 6 }; ` `    ``int` `arr2[] = { 2, 3, 5, 7 }; ` `    ``int` `m = ``sizeof``(arr1) / ``sizeof``(arr1); ` `    ``int` `n = ``sizeof``(arr2) / ``sizeof``(arr2); ` `    ``printIntersection(arr1, arr2, m, n); ` `    ``getchar``(); ` `    ``return` `0; ` `} `

## Java

 `// Java program to find intersection of ` `// two sorted arrays ` ` `  `class` `FindIntersection { ` `    ``/* Function prints Intersection of arr1[] and arr2[] ` `       ``m is the number of elements in arr1[] ` `       ``n is the number of elements in arr2[] */` `    ``static` `void` `printIntersection(``int` `arr1[], ``int` `arr2[], ``int` `m, ``int` `n) ` `    ``{ ` `        ``int` `i = ``0``, j = ``0``; ` `        ``while` `(i < m && j < n) { ` `            ``if` `(arr1[i] < arr2[j]) ` `                ``i++; ` `            ``else` `if` `(arr2[j] < arr1[i]) ` `                ``j++; ` `            ``else` `{ ` `                ``System.out.print(arr2[j++] + ``" "``); ` `                ``i++; ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``public` `static` `void` `main(String args[]) ` `    ``{ ` `        ``int` `arr1[] = { ``1``, ``2``, ``4``, ``5``, ``6` `}; ` `        ``int` `arr2[] = { ``2``, ``3``, ``5``, ``7` `}; ` `        ``int` `m = arr1.length; ` `        ``int` `n = arr2.length; ` `        ``printIntersection(arr1, arr2, m, n); ` `    ``} ` `} `

## Python

 `# Python program to find intersection of ` `# two sorted arrays ` `# Function prints Intersection of arr1[] and arr2[] ` `# m is the number of elements in arr1[] ` `# n is the number of elements in arr2[] ` `def` `printIntersection(arr1, arr2, m, n): ` `    ``i, j ``=` `0``, ``0` `    ``while` `i < m ``and` `j < n: ` `        ``if` `arr1[i] < arr2[j]: ` `            ``i ``+``=` `1` `        ``elif` `arr2[j] < arr1[i]: ` `            ``j``+``=` `1` `        ``else``: ` `            ``print``(arr2[j]) ` `            ``j ``+``=` `1` `            ``i ``+``=` `1` ` `  `# Driver program to test above function ` `arr1 ``=` `[``1``, ``2``, ``4``, ``5``, ``6``] ` `arr2 ``=` `[``2``, ``3``, ``5``, ``7``] ` `m ``=` `len``(arr1) ` `n ``=` `len``(arr2) ` `printIntersection(arr1, arr2, m, n) ` ` `  `# This code is contributed by Pratik Chhajer `

## C#

 `// C# program to find Intersection of ` `// two sorted arrays ` ` `  `using` `System; ` ` `  `class` `GFG { ` ` `  `    ``/* Function prints Intersection of arr1[] ` `    ``and arr2[] m is the number of elements in arr1[] ` `    ``n is the number of elements in arr2[] */` `    ``static` `void` `printIntersection(``int``[] arr1, ` `                                  ``int``[] arr2, ``int` `m, ``int` `n) ` `    ``{ ` `        ``int` `i = 0, j = 0; ` ` `  `        ``while` `(i < m && j < n) { ` `            ``if` `(arr1[i] < arr2[j]) ` `                ``i++; ` `            ``else` `if` `(arr2[j] < arr1[i]) ` `                ``j++; ` `            ``else` `{ ` `                ``Console.Write(arr2[j++] + ``" "``); ` `                ``i++; ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// driver code ` `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``int``[] arr1 = { 1, 2, 4, 5, 6 }; ` `        ``int``[] arr2 = { 2, 3, 5, 7 }; ` `        ``int` `m = arr1.Length; ` `        ``int` `n = arr2.Length; ` ` `  `        ``printIntersection(arr1, arr2, m, n); ` `    ``} ` `} ` ` `  `// This code is contributed by Sam007 `

## PHP

 ` `

Output:

```2 5
```

Time Complexity : O(m + n)

Handling duplicate in Arrays :
Above code does not handle duplicate elements in arrays. The intersection should not count duplicate elements. To handle duplicates just check whether current element is already present in intersection list. Below is the implementation of this approach.

## Python3

 `# Python3 program to find Intersection of two ` `# Sorted Arrays (Handling Duplicates) ` `def` `IntersectionArray(a, b, n, m): ` `    ``''' ` `    ``:param a: given sorted array a ` `    ``:param n: size of sorted array a ` `    ``:param b: given sorted array b ` `    ``:param m: size of sorted array b ` `    ``:return: array of intersection of two array or -1 ` `    ``'''` ` `  `    ``Intersection ``=` `[] ` `    ``i ``=` `j ``=` `0` `     `  `    ``while` `i < n ``and` `j < m: ` `        ``if` `a[i] ``=``=` `b[j]: ` ` `  `            ``# If duplicate already present in Intersection list ` `            ``if` `len``(Intersection) > ``0` `and` `Intersection[``-``1``] ``=``=` `a[i]: ` `                ``i``+``=` `1` `                ``j``+``=` `1` ` `  `            ``# If no duplicate is present in Intersection list ` `            ``else``: ` `                ``Intersection.append(a[i]) ` `                ``i``+``=` `1` `                ``j``+``=` `1` `        ``elif` `a[i] < b[j]: ` `            ``i``+``=` `1` `        ``else``: ` `            ``j``+``=` `1` `             `  `    ``if` `not` `len``(Intersection): ` `        ``return` `[``-``1``] ` `    ``return` `Intersection ` ` `  `# Driver Code ` `if` `__name__ ``=``=` `"__main__"``: ` ` `  `    ``arr1 ``=` `[``1``, ``2``, ``2``, ``3``, ``4``] ` `    ``arr2 ``=` `[``2``, ``2``, ``4``, ``6``, ``7``, ``8``] ` `     `  `    ``l ``=` `IntersectionArray(arr1, arr2, ``len``(arr1), ``len``(arr2)) ` `    ``print``(``*``l) ` ` `  `# This code is contributed by Abhishek Kumar `

Output:

```2 4
```

Time Complexity : O(m + n)
Auxiliary Space : O(min(m, n))
Another approach that is useful when difference between sizes of two given arrays is significant.
The idea is to iterate through the shorter array and do a binary search for every element of short array in big array (note that arrays are sorted). Time complexity of this solution is O(min(mLogn, nLogm)). This solution works better than the above approach when ratio of larger length to smaller is more than logarithmic order.

See following post for unsorted arrays.
Find Union and Intersection of two unsorted arrays
Please write comments if you find any bug in above codes/algorithms, or find other ways to solve the same problem.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up
Recommended Articles
Page :