這是悅樂書的第207次更新，第219篇原創

01 看題和準備

今天介紹的是LeetCode演算法題中Easy級別的第75題（順位題號是349）。給定兩個陣列，編寫一個函式來計算它們的交集。例如：

輸入：nums1 = [1,2,2,1]，nums2 = [2,2]
輸出：[2]

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

注意：

• 結果中的每個元素都必須是唯一的。

• 結果可以是任何順序。

本次解題使用的開發工具是eclipse，jdk使用的版本是1.8，環境是win7 64位系統，使用Java語言編寫和測試。

02 第一種解法

暴力解法，直接使用兩層迴圈，依次比較兩個陣列中的元素，如果相等，則將其存入HashSet中，這樣可以保證不會出現重複元素，再將HashSet中的元素迭代放入陣列，最後返回該陣列。

此解法的時間複雜度是O(n^2)，空間複雜度是O(n)。

public int[] intersection(int[] nums1, int[] nums2) {
    Set<Integer> set = new HashSet<Integer>();
    for(int i=0; i<nums1.length; i++){
        int tem = nums1[i];
        for (int j=0; j<nums2.length; j++) {
            if (tem == nums2[j]) {
                set.add(tem);
                break;
            }
        }
    }
    int[] result = new int[set.size()];
    int k = 0;
    for (int num : set) {
        result[k++] = num;
    }
    return result;
}
 

03 第二種解法

使用兩個HashSet，先將其中一個數組的元素全部放入第一個HashSet中，然後迭代第二個陣列，先判斷第二個陣列的每一個元素是否存在於第一個HashSet中，如果存在，將其放入第二個HashSet中，然後將第二個HashSet的元素迭代放入新陣列中，最後返回。

此解法因為用到了HashSet的contains方法，因此時間複雜度最好情況是O(n)，最壞情況是O(n^2)，空間複雜度是O(n)。

public int[] intersection2(int[] nums1, int[] nums2) {
    Set<Integer> intersection = new HashSet<Integer>();
    Set<Integer> set = new HashSet<Integer>();
    for (int i : nums1) {
        set.add(i);
    }
    for (int i : nums2) {
        if (set.contains(i)) {
            intersection.add(i);
        }
    }
    int[] answer = new int[intersection.size()];
    int index = 0;
    for (int i : intersection) {
        answer[index++] = i;
    }
    return answer;
}
 

04 第三種解法

先將兩陣列排序，然後使用雙指標，依次判斷兩陣列中的元素是否相等，如果某個元素大於或小於另外一個元素，則將指標向後移動，如果相等，則將元素放入HashSet中，然後將HashSet中的元素迭代放入陣列，最後返回。

因為使用Arrays類的sort方法，所以時間複雜度是O(n log(n))，空間複雜度是O(n)。

public int[] intersection3(int[] nums1, int[] nums2) {
    Set<Integer> set = new HashSet<>();
    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 {
            set.add(nums1[i]);
            i++;
            j++;
        }
    }
    int[] result = new int[set.size()];
    int k = 0;
    for (Integer num : set) {
        result[k++] = num;
    }
    return result;
}

05 第四種解法

此解法和第一種解法類似，只是將內層迴圈換成了二分查詢法，其他的思路都是一樣的。

此解法的時間複雜度是O(nlogn)，空間複雜度是O(n)。

public int[] intersection4(int[] nums1, int[] nums2) {
    Set<Integer> set = new HashSet<>();
    Arrays.sort(nums2);
    for (Integer num : nums1) {
        if (binarySearch(nums2, num)) {
            set.add(num);
        }
    }
    int i = 0;
    int[] result = new int[set.size()];
    for (Integer num : set) {
        result[i++] = num;
    }
    return result;
}

public boolean binarySearch(int[] nums, int target) {
    int low = 0;
    int high = nums.length - 1;
    while (low <= high) {
        int mid = low + (high - low) / 2;
        if (nums[mid] == target) {
            return true;
        }
        if (nums[mid] > target) {
            high = mid - 1;
        } else {
            low = mid + 1;
        }
    }
    return false;
}

06 小結

演算法專題目前已連續日更超過兩個月，演算法題文章75+篇，公眾號對話方塊回覆【資料結構與演算法】、【演算法】、【資料結構】中的任一關鍵詞，獲取系列文章合集。

以上就是全部內容，如果大家有什麼好的解法思路、建議或者其他問題，可以下方留言交流，點贊、留言、轉發就是對我最大的回報和支援！