Intersection of Two Arrays

Intersection of Two Arrays - Problem

Given two integer arrays nums1 and nums2, return an array of their intersection. Each element in the result must be unique and you may return the result in any order.

The intersection contains elements that appear in both arrays, with no duplicates in the final result.

Input & Output

Example 1 — Basic Case

$ Input: nums1 = [1,2,2,1], nums2 = [2,2]

› Output: [2]

💡 Note: The number 2 appears in both arrays. Even though 2 appears multiple times, we only include it once in the result.

Example 2 — Multiple Intersections

$ Input: nums1 = [4,9,5], nums2 = [9,4,9,8,4]

› Output: [4,9]

💡 Note: Both 4 and 9 appear in both arrays. The order in the result doesn't matter, so [9,4] would also be correct.

Example 3 — No Intersection

$ Input: nums1 = [1,2,3], nums2 = [4,5,6]

› Output: []

💡 Note: No elements appear in both arrays, so the intersection is empty.

Constraints

1 ≤ nums1.length, nums2.length ≤ 1000
0 ≤ nums1[i], nums2[i] ≤ 1000

Visualization

Tap to expand

Asked in

G Google 42 a Amazon 38 M Microsoft 25 F Facebook 22

The key insight is using hash sets for O(1) lookups instead of nested loops. Convert one array to a hash set, then check each element of the second array. Best approach is hash set with Time: O(n+m), Space: O(n).

Common Approaches

✓ One Pass Hash

⏱️ Time: N/A Space: N/A

Brute Force - Nested Loops

⏱️ Time: O(n×m) Space: O(min(n,m))

Check every element in nums1 against every element in nums2. Use a set to avoid duplicates in the result. This approach is straightforward but inefficient for large arrays.

Hash Set - Single Pass

⏱️ Time: O(n+m) Space: O(n)

First, convert nums1 to a hash set for O(1) lookups. Then iterate through nums2, checking if each element exists in the hash set. Add matches to result set to ensure uniqueness.

Two Pointers (Sorted Arrays)

⏱️ Time: O(n log n + m log m) Space: O(1)

Sort both arrays, then use two pointers starting from the beginning of each array. Move the pointer with the smaller value forward until both point to equal values. This approach is efficient when arrays are already sorted.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

78.5K Views

High Frequency

~15 min Avg. Time

2.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen