给定两个数组，编写一个函数来计算它们的交集

示例 1：

输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2]

示例 2：

输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出：[9,4]

说明：

输出结果中的每个元素一定是唯一的。
我们可以不考虑输出结果的顺序。

方式1：两个集合

如果使用哈希集合存储元素，则可以在 O(1)O(1) 的时间内判断一个元素是否在集合中，从而降低时间复杂度。

首先使用两个集合分别存储两个数组中的元素，然后遍历较小的集合，判断其中的每个元素是否在另一个集合中，如果元素也在另一个集合中，则将该元素添加到返回值。该方法的时间复杂度可以降低到 O(m+n)

public int[] intersection(int[] nums1, int[] nums2) {
       Set<Integer> set1 = new HashSet<>();
       Set<Integer> set2 = new HashSet<>();
       for(int i : nums1){
           set1.add(i);
       }
       for(int i : nums2){
           if(set1.contains(i)){
               set2.add(i);
           }
       }
       int[] arr = new int[set2.size()];
       int j = 0;
       for(int i : set2){
           arr[j++] = i;
       } 
       return arr;
  }

复杂度分析

时间复杂度：O(m+n)，其中 m 和 n 分别是两个数组的长度。使用两个集合分别存储两个数组中的元素需要 O(m+n) 的时间，遍历较小的集合并判断元素是否在另一个集合中需要 O(min(m,n)) 的时间，因此总时间复杂度是 O(m+n)

空间复杂度：O(m+n)，其中 m 和 n 分别是两个数组的长度。空间复杂度主要取决于两个集合。

方法2：排序 + 双指针

如果两个数组是有序的，则可以使用双指针的方法得到两个数组的交集。

所以首先需要对两个数组进行排序，为了保证加入元素的唯一性，我们需要额外记录一个变量 arr[index] 表示上一次加入答案数组的元素。

1.定义两个指针，分别指向两个数组，对两个数组中指针指向的数进行比较
2.如果相同，并且与arr[index]的值不相同，就加入到结果数组中
3.两个指针进行后移，任意一个指针超出数组范围，则结束
4.若不相同，则将指向较小数字的指针右移一位

public int[] intersection(int[] nums1, int[] nums2) {
     Arrays.sort(nums1);
     Arrays.sort(nums2);

     int index = 0, index1 = 0, index2 = 0;
     int[] arr = new int[nums1.length + nums2.length];
     while(index1 < nums1.length && index2 < nums2.length){
         if(nums1[index1] == nums2[index2]){
             // 保证加入元素的唯一性
             if(index == 0 || nums1[index1] != arr[index - 1]){
                 arr[index++] = nums1[index1];
             }
             index1++;
             index2++;
         }else if(nums1[index1] > nums2[index2]){
             index2++;
         }else{
             index1++;
         }
     }
     return Arrays.copyOfRange(arr, 0, index);
 }

复杂度分析

时间复杂度：O(mlogm+nlogn)，其中 m 和 n 分别是两个数组的长度。对两个数组排序的时间复杂度分别是O(mlogm) 和O(nlogn)，双指针寻找交集元素的时间复杂度是O(m+n)，因此总时间复杂度是 O(mlogm+nlogn)。

空间复杂度：O(logm+logn)，其中 m 和 n 分别是两个数组的长度。空间复杂度主要取决于排序使用的额外空间。