【LeetCode題解】350_兩個數組的交集Ⅱ

【LeetCode題解】350_兩個數組的交集Ⅱ

描述

給定兩個數組，編寫一個函數來計算它們的交集。

示例 1:

輸入: nums1 = [1,2,2,1], nums2 = [2,2]
輸出: [2,2]

示例 2:

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

說明：

• 輸出結果中每個元素出現的次數，應與元素在兩個數組中出現的次數一致。
• 我們可以不考慮輸出結果的順序。

進階:

• 如果給定的數組已經排好序呢？你將如何優化你的算法？
• 如果 nums1 的大小比 nums2 小很多，哪種方法更優？
• 如果 nums2 的元素存儲在磁盤上，磁盤內存是有限的，並且你不能一次加載所有的元素到內存中，你該怎麼辦？

方法一：映射

Java 實現

import java.util.Map;
import java.util.HashMap;
import java.util.List;
import java.util.ArrayList;

class Solution {
    public int[] intersect(int[] nums1, int[] nums2) {
    	if (nums1.length <= 0 || nums2.length <= 0) {
    		return new int[] {};
    	}

        Map<Integer, Integer> map = new HashMap<>();
        for (int num : nums1) {
        	if (map.containsKey(num)) {
        		map.replace(num, map.get(num) + 1);
        	} else {
        		map.put(num, 1);
        	}
        }

        List<Integer> list = new ArrayList<>();
        for (int num : nums2) {
        	if (map.containsKey(num) && map.get(num) > 0) {
        		list.add(num);
        		map.replace(num, map.get(num) - 1);
        	}
        }

        int[] ret = new int[list.size()];
        for (int i = 0; i < list.size(); ++i) {
        	ret[i] = list.get(i);
        }
        return ret;
    }
}
// Runtime: 6 ms
// Your runtime beats 34.15 % of java submissions.

複雜度分析：

• 時間複雜度：$O(n)$
• 空間複雜度：$O(n)$

Python 實現

class Solution:
    def intersect(self, nums1, nums2):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :rtype: List[int]
        """
        if len(nums1) == 0 or len(nums2) == 0:
            return []

        d = dict()
        for num in nums1:
            d[num] = d.get(num, 0) + 1

        ret = list()
        for num in nums2:
            if num in d and d[num] > 0:
                ret.append(num)
                d[num] -= 1

        return ret

# Runtime: 36 ms
# Your runtime beats 100.00 % of python3 submissions.

複雜度分析同上。

類似的 Python 實現

from collections import Counter

class Solution:
    def intersect(self, nums1, nums2):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :rtype: List[int]
        """
        counts = Counter(nums1)

        ret = list()
        for num in nums2:
            if counts[num] > 0:
                ret.append(num)
                counts[num] -= 1

        return ret
    
# Runtime: 36 ms
# Your runtime beats 100.00 % of python3 submissions.

複雜度分析同上。

方法二：雙指針

Java 實現

class Solution {
    public int[] intersect(int[] nums1, int[] nums2) {
    	Arrays.sort(nums1);
    	Arrays.sort(nums2);

    	int i = 0, j = 0, k = 0;
    	int[] tmp = new int[nums1.length];
    	while (i < nums1.length && j < nums2.length) {
    		if (nums1[i] < nums2[j]) {
    			++i;
    		} else if (nums1[i] > nums2[j]) {
    			++j;
    		} else {
    			tmp[k++] = nums1[i];
    			++i;
    			++j;
    		}
    	}

    	int[] ret = new int[k];
    	for (int m = 0; m < k; ++m) {
    		ret[m] = tmp[m];
    	}
    	return ret;
    }
}
// Runtime: 1 ms
// Your runtime beats 100.00 % of java submissions.

複雜度分析：

• 時間複雜度：$O(nlog(n))$
• 空間複雜度：$O(n)$

Python 實現

class Solution:
    def intersect(self, nums1, nums2):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :rtype: List[int]
        """
        nums1, nums2 = sorted(nums1), sorted(nums2)
        i, j = 0, 0
        ret = list()
        while True:
            try:
                if nums1[i] < nums2[j]:
                    i += 1
                elif nums1[i] > nums2[j]:
                    j += 1
                else:
                    ret.append(nums1[i])
                    i += 1
                    j += 1
            except IndexError:
                break

        return ret
# Runtime: 40 ms
# Your runtime beats 98.91 % of python3 submissions.

複雜度分析同上。