【leetCode】两个数组的交集

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

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

说明：

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

解法1: 使用hash

时间复杂度: O(m+n)，其中 n 和 m 是数组的长度

空间复杂度: O(m+n)，最坏的情况是数组中的所有元素都不同。

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        Set<Integer> set = new TreeSet<>();
        Set<Integer> resSet = new HashSet<>();
        for (int i : nums1) {
            set.add(i);
        }
        for (int i : nums2) {
            if (set.contains(i)) {
                resSet.add(i);
            }
        }
        int[] res = new int[resSet.size()];
        int inx = 0;
        for (int i: resSet) {
            res[inx++] = i; 
        }
        return res;
    }
}

解法2:使用布尔数组过滤

时间复杂度：一般情况下是 O(m+n+k)，其中 n 和 m 是数组的长度，交集数量为k，两次遍历nums1的复杂度均为O(m),一次遍历nums2为O(n)，Arrays.copyOf(res, idx)内部使用System.arraycopy的复杂度为O(k)。

空间复杂度：最坏的情况是 O(2(max-min+1)), 即第一个数组的数值范围。

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        int min = Integer.MAX_VALUE;
        int max = Integer.MIN_VALUE;
        for (int i : nums1) {
            if (i > max) {
                max = i;
            }
            if (i < min) {
                min = i;
            }
        }
        boolean[] flag = new boolean[max-min+1];
        for (int i : nums1) {
            flag[i-min] = true;
        }
        int[] res = new int[max-min+1];
        int idx = 0;
        for (int i : nums2) {
            if (i >= min && i <= max && flag[i-min]) {
                res[idx++] = i;
                flag[i-min] = false;
            }
            
        }
        return Arrays.copyOf(res, idx);
    }
}

解法3: 二分查找(代码略)

思路： 将较短的数组a排序，遍历另一个数组b，使用二分查找的方法，从数组a查找b，放入Set

时间复杂度：O(NlogN)。排序O(mlogm)，遍历即二分查找O(nlogm)。

空间复杂度：O(min(m,n)).