Leetcode349. 两个数组的交集

Leetcode349. 两个数组的交集

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

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

说明:
输出结果中的每个元素一定是唯一的。
我们可以不考虑输出结果的顺序。
题解：
方案一：两个hashSet
使用两个hashSet，其中一个数组转成hashSet，循环遍历另一个数组中的元素是否在set中，如果在，存入另一个hashSet中，最后将后一个hashSet转成数组即是结果。
方案二：双指针法
将两个数组排序，然后从头到尾遍历，如果两个数组元素相等，放入新的hashSet中，最后hashSet转成数组即可。
方案三：二分法
将一个数组的元素和另一个数组使用二分法比较，看是否在另一个数组中，如果在，放入新的hashSet中，最后hashSet转成数组即可。
scala代码：

/**
    * 使用两个hash表
    * set1.&(set2)
    * set1.intersect(set2)
    *
    * @param nums1
    * @param nums2
    * @return
    */
  def intersection(nums1: Array[Int], nums2: Array[Int]): Array[Int] = {
    val set1 = new util.HashSet[Int]()
    val set2 = new util.HashSet[Int]()

    for (num1 <- nums1) {
      set1.add(num1)
    }

    for (num2 <- nums2) {
      if (set1.contains(num2)) {
        set2.add(num2)
      }
    }
    val value: Array[AnyRef] = set2.toArray()
    val ints: Array[Int] = value.map(x => {
      x.toString.toInt
    })
    ints
  }

 /**
    * 双指针
    * 先将两个数组排序
    *
    * @param nums1
    * @param nums2
    * @return
    */
  def intersection2(nums1: Array[Int], nums2: Array[Int]): Array[Int] = {
    util.Arrays.sort(nums1)
    util.Arrays.sort(nums2)

    val set = new util.HashSet[Int]()
    var i = 0
    var j = 0
    while (i < nums1.length && j < nums2.length) {
      if (nums1(i) == nums2(j)) {
        set.add(nums1(i))
        i = i + 1
        j = j + 1
      } else if (nums1(i) > nums2(j)) {
        j = j + 1
      } else {
        i = i + 1
      }
    }
    val value: Array[AnyRef] = set.toArray()
    val ints: Array[Int] = value.map(x => {
      x.toString.toInt
    })
    ints
  }

/**
    * 二分查找
    *
    * @param nums1
    * @param nums2
    * @return
    */
  def intersection3(nums1: Array[Int], nums2: Array[Int]): Array[Int] = {
    util.Arrays.sort(nums1)

    val set = new util.HashSet[Int]()
    for (num <- nums2) {
      if (binarySearch(nums1, num)) {
        set.add(num)
      }
    }

    val value: Array[AnyRef] = set.toArray()
    val ints: Array[Int] = value.map(x => {
      x.toString.toInt
    })
    ints
  }


  def binarySearch(nums: Array[Int], target: Int): Boolean = {
    var flag = true
    var result = false
    var left = 0
    var right = nums.length - 1
    while (left <= right && flag) {
      val mid = left + (right - left) / 2
      if (target == nums(mid)) {
        result = true
        flag = false
      } else if (target > nums(mid)) {
        left = mid + 1
      } else {
        right = mid - 1
      }
    }
    result
  }

java代码：

   /**
     * 双指针，写入set用来去重
     *
     * @param nums1
     * @param nums2
     * @return
     */
    public static int[] intersection(int[] nums1, int[] nums2) {

        Arrays.sort(nums1);
        Arrays.sort(nums2);
        int i = 0;
        int j = 0;
        HashSet<Integer> set = new HashSet<>();
        while (i < nums1.length && j < nums2.length) {
            if (nums1[i] == nums2[j]) {
                set.add(nums1[i]);
                i++;
                j++;
            } else if (nums1[i] > nums2[j]) {
                j++;
            } else {
                i++;
            }
        }
        int[] new_num = new int[set.size()];
        int x = 0;
        for (int y : set) {
            new_num[x] = y;
            x++;
        }
        return new_num;

    }


    /**
     * 使用二分法，判断一个数组中的元素是否在另一个数组中，如果在，添加到set中
     *
     * @param nums1
     * @param nums2
     * @return
     */
    public static int[] intersection2(int[] nums1, int[] nums2) {

        Arrays.sort(nums2);
        HashSet<Integer> set = new HashSet<>();
        for (int num : nums1) {
            if (binarySearch(num, nums2)) {
                set.add(num);
            }
        }

        int[] new_nums = new int[set.size()];
        int i = 0;
        for (int s : set) {
            new_nums[i] = s;
            i++;
        }
        return new_nums;
    }

    private static boolean binarySearch(int num, int[] nums2) {
        int left = 0;
        int right = nums2.length - 1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (num == nums2[mid]) {
                return true;
            } else if (num > nums2[mid]) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }

        }
        return false;
    }