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 的元素存储在磁盘上,内存是有限的,并且你不能一次加载所有的元素到内存中,你该怎么办?

题目来源:力扣(LeetCode)
链接:https://leetcode-cn.com/problems/intersection-of-two-arrays-ii
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。

我的思路:

首先,最简单的方法,迭代nums1[N],再嵌套迭代nums2[M],比较如果相同记录下来,时间复杂度O(N*M)。但这个方法也有问题,如果nums1 = [1,2,2,2,1],nums2 = [2,2],这个时候输出应该是[2,2],简单的迭代输出显然是[2,2,2]。

第二个思路,先将nums1和nums2处理成两个Map,key存数组中的元素,value存该元素出现的次数。然后我们再迭代,这样就保障了元素出现次数的正确。

class Solution {
    public int[] intersect(int[] nums1, int[] nums2) {
        HashMap map1 = new HashMap<>(nums1.length);
        HashMap map2 = new HashMap<>(nums2.length);
        HashMap resultMap = new HashMap<>(Math.max(nums1.length, nums2.length));
        List resultList = new ArrayList<>();
        for (int a : nums1) {
            if (map1.containsKey(a)) {
                int temp = map1.get(a);
                map1.replace(a, ++temp);
            } else {
                map1.put(a, 1);
            }
        }
        for (int a : nums2) {
            if (map2.containsKey(a)) {
                int temp = map2.get(a);
                map2.replace(a, ++temp);
            } else {
                map2.put(a, 1);
            }
        }
        for (Map.Entry entry : map1.entrySet()) {
            int key = entry.getKey();
            int value = entry.getValue();
            if (map2.containsKey(key)) {
                resultMap.put(key, Math.min(value, map2.get(key)));
            }
        }
        for (Map.Entry entry : resultMap.entrySet()) {
            for (int i = 0; i < entry.getValue(); i++) {
                resultList.add(entry.getKey());
            }
        }
        return resultList.stream().mapToInt(Integer::valueOf).toArray();
    }
}

当然,可以看下这个题解。这个是我在github上找的一个热门的算法题解项目(小浩算法)。当然,官方的题解也很不错,Leetcode牛逼。

Leetcode官方给出的哈希题解相比个人的解法有了一个更好的优化,及我们只需要把最长的那个数组转为hash表,然后遍历另一个数组,当数组中某一元素在hash表中存在同时其value>0,则将该元素记录下来并将value--。这个的好处在于时间复杂度确定了O(min(N,M)),同时也只用对一个数组进行hash转换。

class Solution {
    public int[] intersect(int[] nums1, int[] nums2) {
        // 这里很精彩,通过一个递归保证nums1始终为最长的数组
        if (nums1.length > nums2.length) {
            return intersect(nums2, nums1);
        }
        // nums1转hash表
        Map map = new HashMap();
        for (int num : nums1) {
            int count = map.getOrDefault(num, 0) + 1;
            map.put(num, count);
        }
        int[] intersection = new int[nums1.length];
        // index为输出数组下标
        int index = 0;
        // 遍历nums2
        for (int num : nums2) {
            // 获取key对应的value,key不存在返回0
            int count = map.getOrDefault(num, 0);
            // 当count>0时,进行下一步计算
            if (count > 0) {
                // 先将key放入输出数组,在将下标指向下一位
                intersection[index++] = num;
                // 计数减一
                count--;
                // 这里是对map的整理,个人感觉除非remove比put快很多,否则不需要再做一次判断
                if (count > 0) {
                    map.put(num, count);
                } else {
                    map.remove(num);
                }
            }
        }
        // Arrays.copyOfRange方法,将数组从下标0到下标index截取并返回一个新数组
        return Arrays.copyOfRange(intersection, 0, index);
    }
}

进阶:

如果给定的数组已经排好序呢?将如何优化你的算法呢?

这里我确实没什么思路。所以看看别人的解法,揣测下别人的思路。这里是leetcode官方的题解二。

class Solution {
    public int[] intersect(int[] nums1, int[] nums2) {
        // 先排序
        Arrays.sort(nums1);
        Arrays.sort(nums2);
        int length1 = nums1.length, length2 = nums2.length;
        int[] intersection = new int[Math.min(length1, length2)];
        // 使用双指针,index1指向nums1,index2指向nums2,index指向输出数组
        int index1 = 0, index2 = 0, index = 0;
        // 迭代,当双指针中有一个遍历完数组后,跳出循环
        while (index1 < length1 && index2 < length2) {
            // 两个下标指向的元素比较大小,小的向后移一位。注意这里是已从小到大排好序了
            if (nums1[index1] < nums2[index2]) {
                index1++;
            } else if (nums1[index1] > nums2[index2]) {
                index2++;
            } else {
                // 相同的情况下,双指针向后移一位,记录该元素,同时index向后移一位
                intersection[index] = nums1[index1];
                index1++;
                index2++;
                index++;
            }
        }
        return Arrays.copyOfRange(intersection, 0, index);
    }
}

使用sort()方法,其底层是用的二分法。二分法的时间复杂度为logn 。所以此时间复杂度为O(mlogm + nlogn)。

如果 nums1 的大小比 nums2 小很多,哪种方法更优?

这种显然是第一种hash的更优

如果 nums2 的元素存储在磁盘上,内存是有限的,并且你不能一次加载所有的元素到内存中,你该怎么办?

在leetcode的解答上有两种说法,一种是使用方法一更优,一种是考虑使用外部磁盘,可以使用外部排序,及归并排序,将两个小文件和成一个大文件,并排好序。个人觉得仁者见仁智者见智了。

你可能感兴趣的:(leetcode探索之旅(350))