两个数组的交集

关于两个数组的交集

给定两个数组 nums1 和 nums2 ，返回 它们的交集 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。

1、扒拉扒拉新接触（不一定用到）

auto关键字（仅C++）

用法：for(auto i：num1)
解释：从num1中自行判断数据类型，num1中数据类型为int，auto在上述用法中就等同于int。i依次赋值num1中的值直到容器结束，相当于for(auto i=num1.begin();i!=num1.end();++i)。
补充：但上述用法无法影响到容器中的值，想要修改需要使用引用符&,例如for(auto &i：num1)，然后在循环中对i进行操作即可。

接上提一下C++自带范围for循环

用法：for(int i：num1)//数据类型int可换
解释：对容器num1遍历，想要修改容器或数组中的值需要引用符，例如for(int &i：num1)。

Hashset/unordered_set

用法：

HashSet<Integer> hashSet = new HashSet<>();//java创建对象，<>中必须是包装过的泛型，因此不能直接使用int等基本数据类型
unordered_set<int> hashSet;    //c++用法，需头文件#include <unordered_set>

解释：HashSet是没有重复元素的无序集合，适用于取唯一值。unordered_set同理，用于c++中。把数据通过遍历添加到HahSet中，相同的数据只会保留一个，添加语句如下

hashSet.add(i);//java添加，i可以是int
hashSet.insert(i);//c++添加

补充：unordered_set在C++11的时候被引入标准库，但是hashSet没有，所以c++只能用unordered_set。

迭代器Iterator

用法：

 Iterator<int> it=hashSet.iterator;//java初始化迭代器对象
 while(it.hasNext){}

解释：新建迭代器对象，iterator迭代器常用方法如下：

boolean hasNext();//如果下一元素存在，返回true，其他返回false
next();//移动到下一元素，并返回值
void remove();//删除元素

2、思路

两个for循环把交集存入hashset取唯一值，再转为数组
时间复杂度:O(nm)+O(a)=O(mn)
结果：pass
c++代码：

#include <unordered_set>
class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> hashSet;
        for(int i=0;i<nums1.size();i++)
        {
            for(int j=0;j<nums2.size();j++){
                if(nums1[i]==nums2[j])
                {
                    hashSet.insert(nums1[i]);
                }
            }
        }
        vector<int> a(hashSet.size());
        int i=0;
        for(int x:hashSet)
        {
            a[i++]=x;
        }
        return a;
    }
};

3、解

虽说思路过了，但是，既然用了hashset，其中的方法明显比遍历查找方便，比如

//c++
hashSet.find(i)  //查找数值i
hashSet.erase(i) //删除数值i
//java
hashSet.contains(i) //是否包含数值i
hashSet.remove(i)  //删除数值i

改进：将其中一个数组存入hashSet，用另一个数组查找与它相同的值，查到加入结果数组，并删除hashset里的这个元素防止重复。
时间复杂度：不知道hashSet的find应不应该算进去，不算的话应该是O(n)，算进去应该也是O(n)?
c++代码：

#include <unordered_set>
class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        vector<int> a;
        unordered_set<int> hashSet;
        for(int i:nums1)
        {
           hashSet.insert(i);
        }
        for(int i:nums2)
        {
            if(hashSet.find(i)!=hashSet.end())
            {
                a.push_back(i);
                hashSet.erase(i);
            }
        }
        return a;
    }
};

Java代码：

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        List<Integer> a=new ArrayList();
        HashSet<Integer> hashSet = new HashSet<>();
        for(int i:nums1)
        {
            hashSet.add(i);
        }
        for(int i:nums2)
        {
            if(hashSet.contains(i))
            {
                a.add(i);
                hashSet.remove(i);
            }
        }
       int[] a_int=a.stream().mapToInt(Integer::intValue).toArray();
       //int[] arr2 = a.stream().mapToInt(Integer::valueOf).toArray();
        return a_int;
    }
}

4、for循环范围迭代、Iterator迭代器迭代和容器（如vector、hashSet）自带迭代（待完善）