20231212-Day 13-点亮代码技能

Leetcode349（代码随想录：两个数组的交集）

C++：

一、vector对象: vector<int> nums;

        1. 求vector数组长度：nums.size();

        2. 在数组尾部插入元素elem：nums.push_back(elem);

        3. 删除数组尾部最后一个元素：nums.pop_back();

        4. 删除位置pos的元素：nums.erase(const pos);

        5. 删除位置begin到end之间的元素：nums.erase(const begin, const end);

        6. 创建vector数组：

        （1）一维：vector<int> result(nums.size(), 0);初始化元素值为0，元素个数为nums.size()的一维数组；

        （2）二维：vector<vector<int>> result(row, vector<int>(column, 0));初始化row*column的二维数组，初始化值为0；

        7. 数组第一个元素：nums.begin();

        8. 数组最后一个元素：nums.end();

        9. 使用sort对数组进行排序需要包含头文件#include<algorithm>:

        （1）对数组升序排序：sort(nums.begin(), nums.end());

        （2）对数组降序排序：sort(nums.begin(), nums.end(), greater<int>());

        10. std::cout不能直接输出整个vector数组，需要对vector数组遍历依次输出；

二、知识：

        1. INT32_MAX：需要#include<limits.h>，是一个宏定义，数值等于2147483647;

        2. for循环的自动迭代：for(int i : nums);

三、unordered_set对象：unordered_set<int>result;

        1. 求集合大小：result.size();

        2. 在集合插入元素elem：result.insert(elem);

        3. result.begin()：返回unordered_set第一个元素的迭代器;

        4. result.end()：返回unordered_set最后一个元素下一个位置的迭代器;

        5. 查找集合中是否有元素elem，如果找到指定元素，它返回元素的迭代器，如果找不到指定元素，则返回指向result.end()的迭代器：result.find(elem);

使用unordered_set解决：

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result;
        unordered_set<int> setnum1(nums1.begin(), nums1.end());
        for(int num : nums2)
        {
            if(setnum1.find(num) != setnum1.end())
                result.insert(num);
        }
        return vector<int>(result.begin(), result.end());
    }
};

使用数组解决：

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result;
        int shuzu[1005] = {0};
        for(int num : nums1)
        {
            shuzu[num] = 1;
        }
        for(int num : nums2)
        {
            if(shuzu[num] == 1)
                result.insert(num);
        }
        return vector<int>(result.begin(), result.end());
    }
};

Python：

1. python求数组nums长度：

        len(nums)

2. python取整：

        middle = (left + right) // 2

3. python移除数组nums中的元素val：

        nums.remove(val)

4.（1）python升序排序，列表本身修改：

                nums.sort()

   （2）python升序排序，返回新列表：

                sorted(nums)

5.（1）列表地址相同：result = nums

   （2）创建列表副本：result = nums[:]

6.（1）float('inf')：正无穷大

   （2）float('-inf')：负无穷大

7.（1）建立二维列表的方法：result = [[0] * n for _ in range(n)]

   （2）建立一维全0列表的方法：result = [0 for _ in range(n)]

8. ord()：python内置函数，用于返回字符的Unicode码

9. collections模块中的defaultdict：可以设置默认值的字典dict，defaultdict的第一个参数是一个可调用对象，它用于生成默认值，例如int, list, set等。

10. collections模块中的Counter：Counter是一个简单的计数器，例如，统计字符出现的个数

   （1）elements()方法：返回一个迭代器，可以通过 list 或者其它方法将迭代器中的元素输出，输出的结果为对应出现次数的元素

   （2）most_common()方法：返回一个出现次数从大到小的前 n 个元素的列表

11. python数据类型——集合set：

   （1）定义：集合是不可重复的、无序的、不可改变的类型，a = set()

   （2）添加元素：a.add(elem) 添加单个元素，a.update(elems) 添加多个元素并且自动舍去重复元素

   （3）删除元素：a.pop() 随机删除单个元素，a.remove(elem) 删除指定元素，a.clear() 清空集合，del a 删除集合

   （4）交集：a.intersection(b) 或 a & b

   （5）反交集：a.symmetric_difference(b) 或 a ^ b

   （6）并集：a.union(b) 或 a | b

   （7）差集：a.difference(b) 或 a - b

12. python数据类型——字典dict：

   （1）定义：字典元素以键值对存在：key(键):value(值)，d = {}

   （2）d[key] = d.get(key,0)+1：d[key]表示键为key的值value，找不到则报错；d.get(key,0)表示找到键为key的值，找不到则赋值为0

 使用字典和集合：

class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        table = {}
        for num in nums1:
            table[num] = table.get(num, 0) + 1
        result = set()
        for num in nums2:
            if num in table:
                result.add(num)
                del table[num]
        return list(result)

 使用数组：

class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        count1 = [0] * 1001
        count2 = [0] * 1001
        result = []
        for i in nums1:
            count1[i] += 1
        for i in nums2:
            count2[i] += 1
        for k in range(1001):
            if count1[k] * count2[k] > 0:
                result.append(k)
        return result

 使用集合：

class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        return list(set(nums1) & set(nums2))

自己写的（看了代码随想录示例后感觉好垃圾）：

class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        from collections import defaultdict
        num_dict = defaultdict(int)
        result = []
        for num in nums1:
            num_dict[num] = 1
        for num in nums2:
            if num_dict[num] == 1:
                result.append(num)
        result.sort()
        slow = 0
        for fast in range(len(result)):
            if result[fast] != result[slow]:
                slow += 1
                result[slow] = result[fast]
        return result[: slow+1]