【LeetCode】set和map容器、两类查找问题

一、容器的常见操作：

1. 插入：insert
2. 查找：find
3. 删除：erase
4. 替换：change（仅map使用）
5. 迭代：

set<int> resultSet;
int a = 3;
"插入"
resultSet.insert(a);

"查找"
if(resultSet.find(a) != resultSet.end()){
    cout <<endl;
}

"删除"
resultSet.erase(a);

"迭代" 使用迭代器
for(set<int>iterator iter = resultSet.begin(); iter != resultSet.end(); iter++){
    cout<< *iter <<endl;
}

"map插入"
"map中存放的是键值对，所以插入的时候也需要用pair构建一个键值对再插入"
map<int,int> mymap;
map.insert(make_pair(10, 1));    

二、set和map的底层实现

1. map和set的底层实现为平衡二叉树；
2. unordered_map和unordered_set的底层实现为哈希表；
3. 哈希表缺点：失去了数据的顺序性。

三、查找问题：

1、查找有无

• 元素“a”是否存在？使用set：集合

2、查找对应关系（键值对应）

• 元素'a'出现了几次？map：字典

LeetCode349. 两个数组的交集

问题：给定两个数组，编写一个函数来计算它们的交集。
示例 1：
输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出：[9,4]

说明：
输出结果中的每个元素一定是唯一的。我们可以不考虑输出结果的顺序。

思路：

计算两个数组的交集，可以通过set容器的方式计算，将数组1塞到set容器中，然后循环查找数组2中的元素是否在set容器中。

"计算交集，可以用set容器操作"
//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> recode(nums1.begin(), nums1.end());

        unordered_set<int> result;
        for(auto item : nums2){
            if(recode.find(item) != recode.end()){
                result.insert(item);
            }
        }

        return vector<int>(result.begin(), result.end());
    }
};

LeetCode350. 两个数组的交集 II。

给定两个数组，编写一个函数来计算它们的交集。
 示例 1：
 输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2,2]

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

 说明：
 输出结果中每个元素出现的次数，应与元素在两个数组中出现次数的最小值一致。 
 我们可以不考虑输出结果的顺序。 

 进阶：
 如果给定的数组已经排好序呢？你将如何优化你的算法？ 
 如果 nums1 的大小比 nums2 小很多，哪种方法更优？ 
 如果 nums2 的元素存储在磁盘上，内存是有限的，并且你不能一次加载所有的元素到内存中，你该怎么办？ 

思路：使用map容器。

class Solution {
public:
    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
        unordered_map<int,int> v_map1;
        for(auto item : nums1){
            v_map1[item]++;
        }

        vector<int> v_result;
        for(auto item : nums2){
            if(v_map1[item] > 0){
                v_result.push_back(item);
                v_map1[item]--;
            }
        }
        return v_result;
    }
};

方法二：排序 + 双指针（效率更高）

class Solution {
public:
    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
        sort(nums1.begin(), nums1.end());
        sort(nums2.begin(), nums2.end());

        vector<int> v_result;
        "双指针移动"
        int k = 0, j = 0;
        while (k < nums1.size() && j < nums2.size()){
            if(nums1[k] == nums2[j]){
                v_result.push_back(nums1[k]);
                k++;
                j++;
            }
            else if(nums1[k] < nums2[j]){
                k++;
            }
            else{
                j++;
            }
        }
        return v_result;
    }
};