349. Intersection of Two Arrays

Given two arrays, write a function to compute their intersection.

Example:
Given nums1 = [1, 2, 2, 1], nums2 = [2, 2], return [2].

Note:

• Each element in the result must be unique.
• The result can be in any order.

本题解法比较多，先来说一说我的解法：1.将两个数组进行排序，然后创建两个指针对这两个数组进行遍历，（假设指针为i，j），如果nums1[i]<nums2[j],那么i++；如果nums1[i]>nums2[j]，那么j++；否则如果两个值相等，则将其值放入hashset里面，代码如下：

public class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        Set<Integer> set = new HashSet<Integer>();
        if(nums1==null||nums1.length==0||nums2==null||nums2.length==0) return new int[0];
        Arrays.sort(nums1);
        Arrays.sort(nums2);
        int i=0;
        int j=0;
        while(i!=nums1.length&&j!=nums2.length){
            if(nums1[i]<nums2[j]){
                i++;
            }else if(nums1[i]>nums2[j]){
                j++;
            }else{
               // System.out.println(nums1[i]);
                set.add(nums1[i]);
                i++;
                j++;
            }
        }
        int[] res= new int[set.size()];
        int q = 0;
        for(int k:set){
            res[q++]=k;
        }
        return res;
    }
}

上述代码的时间复杂度为O（nlongn）；

第二种方法与之前的Repeated DNA Sequence比较类似，都是创建两个hashset，第一个来保存第一个数组的元素，然后检测是否第二个数组包括第一个数组里面元素，

如果包括，则把它放入第二个hashset里面。他和DNAsequence有个不同之处在于，DNA的第二个hashset用来剔除掉第三次出现的情况；这种双hashset的问题可以用来解决字符重复性的问题，代码如下：

public class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        Set<Integer> set = new HashSet<Integer>();
        Set<Integer> res = new HashSet<Integer>();
        for(int i:nums1){
            set.add(i);
        }
        for(int i:nums2){
            if(set.contains(i)){
                res.add(i);
            }
        }
        int[] result = new int[res.size()];
        int k =0;
        for(Integer i:res){
            result[k++] = i;
        }
        return result;
    }
}
// run time complexity is O(max(nums1.length,nums2.length)) space complexity O(min(nums1.length,nums2.length))

 

上述方法的时间复杂度是O（n）；

第三种方法就是使用二分查找法，对其中的一个数组进行排序，遍历另外一个数组，对另外一个数组的每个num都进行查找，如果找到了，则说明这两个数组都含有这个值，将其放入hashset里面，否则则不包含，代码如下：

public class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        Set<Integer> set = new HashSet<Integer>();
        Arrays.sort(nums2);
        for(int i:nums1){
            if(binarySearch(nums2,i)){
                set.add(i);
            }
        }
        int[] res = new int[set.size()];
        int v = 0;
        for(int i:set){
            res[v++] = i;
        }
        return res;
    }
    public boolean binarySearch(int[] nums,int target){
        int i=0;
        int j = nums.length-1;
        while(i<=j){
            int mid = i+(j-i)/2;
            if(nums[mid]==target) return true;
            else if(nums[mid]<target) i = mid+1;
            else j = mid-1;
        }
        return false;
    }
}