給定兩個整型陣列，編寫一個函式來計算它們的交集。

• 輸入：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)).