Leetcode350. 两个数组的交集 II

Leetcode350. 两个数组的交集 II

题目：
给定两个数组，编写一个函数来计算它们的交集。
示例 1:

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

题解：
方案一：hash映射

1. 新建一个hashMap，将其中小的数组遍历存入hashMap中，key存数组的值，value存数组每个值的次数；
2. 遍历第二个数组，如果在hashMap中存在，将数组中的元素拷贝到第一个数组中，并减少对应的次数。
3. 最后将第一个数组中新存入的数据以新的数组反回即可。

方案二：双指针

1. 首先将两个数组排序；
2. 使用双指针分别遍历两个数组，如果数组元素相同，将此元素存入数组中；如果不相同，将小数往后继续遍历一次，再次进行比较，依次类推。

java代码：

public static int[] intersect(int[] num1, int[] num2) {
        if (num1.length > num2.length) {
            intersect(num2, num1);
        }

        HashMap<Integer, Integer> map = new HashMap<>();
        for (int n : num1) {
            map.put(n, map.getOrDefault(n, 0) + 1);
        }

        int k = 0;
        for (int n2 : num2) {
            Integer i = map.getOrDefault(n2, 0);
            if (i != 0) {
                num1[k] = n2;
                k++;
                map.put(n2, i - 1);
            }
        }
        return Arrays.copyOfRange(num1, 0, k);
    }

    public static int[] intersect2(int[] num1, int[] num2) {
        Arrays.sort(num1);
        Arrays.sort(num2);

        int i = 0, j = 0, k = 0;
        while (i < num1.length && j < num2.length) {
            if (num1[i] > num2[j]) {
                j++;
            } else if (num1[i] < num2[j]) {
                i++;
            } else {
                num1[k] = num1[i];
                i++;
                j++;
                k++;
            }
        }
        return Arrays.copyOfRange(num1, 0, k);
    }

scala代码：

/**
    * 使用hashMap存储较小的数组
    * @param nums1
    * @param nums2
    * @return
    */
  def intersect(nums1: Array[Int], nums2: Array[Int]): Array[Int] = {
    if (nums1.length > nums2.length) {
      intersect(nums2, nums1)
    }
    val map = new mutable.HashMap[Int, Int]()
    for (num <- nums1) {
      map.put(num, map.getOrElse(num, 0) + 1)
    }
    var k = 0
    for (num <- nums2) {
      val value = map.getOrElse(num, 0)
      if (value != 0) {
        nums1(k) = num
        k = k + 1
        map.put(num, value - 1)
      }
    }
    util.Arrays.copyOfRange(nums1, 0, k)

  }

 def intersect2(nums1: Array[Int], nums2: Array[Int]): Array[Int] = {
    util.Arrays.sort(nums1)
    util.Arrays.sort(nums2)
    var i = 0
    var j = 0
    var k = 0
    while (i < nums1.length && j < nums2.length) {
      if (nums1(i) == nums2(j)) {
        nums1(k) = nums1(i)
        k = k + 1
        i = i + 1
        j = j + 1
      } else if (nums1(i) < nums2(j)) {
        i = i + 1
      } else {
        j = j + 1
      }
    }
    util.Arrays.copyOfRange(nums1, 0, k)
  }