LeetCode算法题-Intersection of Two Arrays（Java实现-四种解法）

最新推荐文章于 2022-03-16 23:04:49 发布

原创最新推荐文章于 2022-03-16 23:04:49 发布 · 135 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#LeetCode #算法题 #面试题

【算法】---LeetCode 专栏收录该内容

274 篇文章

订阅专栏

本文介绍了LeetCode上第349题的四种解法，包括暴力解法、使用HashSet、排序加双指针以及结合二分查找的解法，详细分析了每种方法的时间和空间复杂度。

这是悦乐书的第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;
}