一、题目

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

二、示例

示例 1：
输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2]

示例 2：
输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出：[9,4]

三、解法

方法一：set

分别对两个数组进行去重（用set），然后判断集合大小，在size更小些的集合中查找size更大的集合中是否有该元素，有就加到结果数组中。

/** * @param {number[]} nums1 * @param {number[]} nums2 * @return {number[]} */
var intersection = function(nums1, nums2) {
    
   var set1=new Set(nums1)
   var set2=new Set(nums2)
   var res=[]
   if(set1.size>set2.size)
   {
    
       for(var key of set2.keys())
       {
    
           if(set1.has(key)){
    res.push(key)}
       }
   }
   else{
    
              for(var key of set1.keys())
       {
    
           if(set2.has(key)){
    res.push(key)}
       }
   }
   return res

};

提取一下

var intersection = function(nums1, nums2) {
    
   var set1=new Set(nums1)
   var set2=new Set(nums2)
   if(set1.size>set2.size)
   {
    
       res= find(set2,set1)
   }
   else{
    
       res= find(set1,set2)
   }
   return res
};
var find=function(set1,set2){
    
       var res=[]
           for(var key of set1.keys())
       {
    
           if(set2.has(key)){
    res.push(key)}
       }
       return res
}

知识点：set用法
遍历：利用for(var i of set.keys())或者for(var i of set.values())都可以返回集合中的值。
大小：直接用set.size()就可获得集合长度。
判断集合中是否有某元素调用has方法即可

时间复杂度+空间复杂度

时间复杂度：O(m+n)，其中 mm 和 nn 分别是两个数组的长度。使用两个集合分别存储两个数组中的元素需要 O(m+n)的时间，遍历较小的集合并判断元素是否在另一个集合中需要 O(min(m,n)) 的时间，因此总时间复杂度是 O(m+n)。

空间复杂度：O(m+n)，其中 mm 和 nn 分别是两个数组的长度。空间复杂度主要取决于两个集合。

方法二：正向双指针+额外空间

思路为先对两个数组进行排序，排序后双指针遍历两数组，若相等且不等于上一个加入结果数组的数字，就将其加入到结果数组，且index1++，index2++；若1<2，则index1++；反之index2++

/** * @param {number[]} nums1 * @param {number[]} nums2 * @return {number[]} */
var intersection = function(nums1, nums2) {
    
    nums1.sort((a,b)=>a-b)
    nums2.sort((a,b)=>a-b)

    var index1=0,index2=0
    var res=[]
    while(index1<nums1.length&&index2<nums2.length)
    {
     
        if(nums1[index1]==nums2[index2])
        {
     
            if(!res.length||res[res.length-1]!=nums1[index1])
            {
    
                
                res.push(nums1[index1])
            }
            index1++
            index2++
        }
        else if(nums1[index1]<nums2[index2])
        {
    
            index1++
        }
        else{
    
            index2++
        }
    }
    return res
};

时间复杂度+空间复杂度

时间复杂度：O(mlogm+nlogn)，其中 mm 和 nn 分别是两个数组的长度。对两个数组排序的时间复杂度分别是 O(mlogm) 和 )O(nlogn)，双指针寻找交集元素的时间复杂度是 O(m+n)，因此总时间复杂度是 O(mlogm+nlogn)。

空间复杂度：O(logm+logn)，其中 mm 和 nn 分别是两个数组的长度。空间复杂度主要取决于排序使用的额外空间。

方法三、

var intersection = function(nums1, nums2) {
    
   res =Array.from( new Set(nums1))
   nums2 = new Set(nums2)
   res=res.filter((item)=>{
    
       return nums2.has(item)
   })
   return res
};

var intersection = function(nums1, nums2) {
    
  var arg=Array.from(arguments)
  var res=[]
  arg.forEach((item)=>{
    
      if(!res.length)
      {
    
        res.push(... new Set( item))
      }
      else{
    

          var newSet=new Set(item)     
           res= res.filter((item)=>
            {
    
            
                return newSet.has(item)
            })
      }
    

  })
  return res
};