[代码随想录算法训练营 Day0506 哈希表Part 1]

Day 05

（周日休息）

Day 06

哈希表 Part 02

1. 有效的字母异位词（力扣242）

1.题目描述：有效的字母异位词
2. 思路：判断一个元素是否出现在集合里，用哈希表！这道题不用判断每个字母出现的次数，只用判断是否出现，所以使用set刚刚好！
3. python语法细节：

• python 中 set 用法：
• 底层实现：哈希表，dict实现，添加的元素作为键值，字典的值设为 固定的None。
• 增删改查时间复杂度：O(1)
• 集合元素唯一，且无序
• 创建集合 myset = set()
• 字符串添加 set(mystring)
• 添加元素删除元素set.add(i) set.remove(i)
• 并集交集差集s1&s2 s1|s2 s1-s2

4. python实现

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        set_t =set(s)
        set_s = set(t)

        if set_t == set_s:
            return True
        else:
            return False

5. C++代码细节

• 定义指定长度的空数组：int record[26] = {0}
• 字符串长度：i.size（）i.length()python中用len()
• 字符以ASCII存储，字符之间可以进行加减运算。
• C++中 true false小写 python 中True False

6. C++实现

class Solution {
public:
    bool isAnagram(string s, string t) {
        int record[26] = {0};
        for(int i=0;i<s.size();i++){
            record[s[i]-'a']++;
        }
        for(int i=0;i<t.size();i++){
            record[t[i]-'a']--;
        }
        for(int i=0;i<26;i++){
            if(record[i]!=0){
                return false;
            }
        }
        return true;
        
    }
};

2. 两数组交集(力扣349)

1. 题目描述：
2. 思路：
3. python语法细节:

• set 返回的是集合类型，题目要求的是返回列表，所以用list(set)将其转换

4. python 实现：

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

5. C++语法细节：

• C++中vector 用法
• 创建vector#include <vector> std::vector<int> my_vector;
• 添加元素到末尾my_vector.push_back(i);
• 获取vector大小 int size = my_vector.size();
• 使用 for each循环遍历vectorfor(int num:my_vector){...}
• 获取vector的首个元素或者末尾元素my_vector.front(); my_vector.back();
• 删除末尾元素：my_vector.pop_back();
• 插入元素：my_vector.insert();
• 删除元素：my_vector.erase()
• 集合转化为vector,使用范围构造函数std::vector<int> my_vector(my_set.begin(), my_set.end());
• C++中 unordered_set用法(待总结)

在这里插入代码片

6. C++实现：

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

    }
};

3. 快乐数（力扣202）

1. 题目描述：快乐数
2. 思路：如果一个数不是快乐数，在这个求解过程中就会死循环，不断出现4,16,37,58,89,136,46,42,20这些数字，可以算一算。因此只要判断每一轮算出的数字不曾经出现过就是快乐数，因此判断结果是否在曾经出现过，使用集合。
3. python语法

• 在数字位数不确定的情况下，分别得到每一位数
• set判断元素是否在集合里in
• 向set中添加元素set.add()

4. python实现

class Solution:
    def isHappy(self, n: int) -> bool:
        result = set()
        num = n
        while num not in result:
            result.add(num)
            num =  self.get_digit_sum(num)

            if num==1:
                return True
         
        return False

    def get_digit_sum(self,n:int):
        sum_ = 0
        while n:
            sum_ = sum_+(n%10)**2
            n = n//10
        return sum_

5. C++ 语法细节
6. C++实现（待更新）

4. 两数之和（力扣1）

1. 题目描述：两数之和
2. 思路：遍历数组nums,因为要判断target - num是否出现，所以要用哈希列表。而且要返回出现的索引，因此要用字典来存储，键是出现的元素，值是索引。遍历每个元素时，先判断它的目标值是否在字典里，若没有再把它加入字典。（不能先放入字典再识别，因为以元素的值作为键会有重复的情况。）
3. python语法细节：

• 判断一个键值是否出现在字典里，使用关键字 in
• 将单独的两个元素以列表形式输出，使用[]即可，只有可迭代对象才可以 用list转化为列表。

4. python实现：

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        dict_={}
        l = len(nums)
        for i in range(l):          
            if (target - nums[i]) in dict_:
                return [i,dict_[target - nums[i]]]
            dict_[nums[i]]=i
        return []

5. C++语法细节（待更新）
6. C++实现（待更新）