LeetCode算法题-Intersection of Two Arrays(Java实现-四种解法)

这是悦乐书的第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+篇,公众号对话框回复【数据结构与算法】、【算法】、【数据结构】中的任一关键词,获取系列文章合集。

以上就是全部内容,如果大家有什么好的解法思路、建议或者其他问题,可以下方留言交流,点赞、留言、转发就是对我最大的回报和支持!

posted @ 2018-12-20 08:16  程序员小川  阅读(439)  评论(0编辑  收藏  举报