代码随想录算法训练营Day06 | 哈希表理论基础 242.有效的字母异位词 349. 两个数组的交集 202. 快乐数 1. 两数之和

当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法。

文章讲解：代码随想录

补充知识点

vector：

vector是STL的动态数组，可以在运行中根据需要改变数组的大小。

因为它以数组的形式储存，所以它的内存空间是连续的。

vector的头文件为#include<vector>

常用方法：

1.vector<int>a                                  创建一个动态数组a，a的默认初值为0

2.vector<int >b(a)                             将a中的元素复制到b中

3.vetcor<int>a(100)                          将数组a的元素定义为100个，默认初始值为0

4.vector<int>a(100,6)                       定义100个值为6的元素

5.vector<string>a(10,"null")              定义10个值为null的元素

6.vector<string>a(10,"hello")             定义10个值为hello的元素

7.vector<string>b(a.begin(),a.end())  将动态数组a的元素值复制到b中

常用操作：

1.a.push_back(100)                            在尾部加入一个值为100的元素

2.a.size()                                              返回数组中元素的个数

3.bool isEmpty=a.empty()                    判断a是否为空，若为空返回true，若不为空则返回false

4.cout<<a[0]<<endl                               输出数组的大小

5.a.insert(a.begin+i,k)                           在第i个元素前插入k

6.a.insert(a.end(),10,5)                         在末尾插入10个值为5的元素

7.a.pop_back                                        删除末尾元素

8.a.erase(a.begin()+i,a.begin()+j)         将[i,j-1]的元素都删除

9.a.erase(a.begin()+i)                           将第i+1个元素删除

10.a.resize(n)                                        将数组重置为n个元素

11.a.clear()                                             清空数组

12.reverse(a.begin(),a.end())                 将数组逆转

13.sort(a.begin(),a.end())                       将数组从小到大排序

unordered_set:

成员方法    功能
begin()    返回指向容器中第一个元素的正向迭代器。
end();    返回指向容器中最后一个元素之后位置的正向迭代器。
cbegin()    和 begin() 功能相同，只不过其返回的是 const 类型的正向迭代器。
cend()    和 end() 功能相同，只不过其返回的是 const 类型的正向迭代器。
empty()    若容器为空，则返回 true；否则 false。
size()    返回当前容器中存有元素的个数。
max_size()    返回容器所能容纳元素的最大个数，不同的操作系统，其返回值亦不相同。
find(key)    查找以值为 key 的元素，如果找到，则返回一个指向该元素的正向迭代器；反之，则返回一个指向容器中最后一个元素之后位置的迭代器（如果 end() 方法返回的迭代器）。
count(key)    在容器中查找值为 key 的元素的个数。
equal_range(key)    返回一个 pair 对象，其包含 2 个迭代器，用于表明当前容器中值为 key 的元素所在的范围。
emplace()    向容器中添加新元素，效率比 insert() 方法高。
emplace_hint()    向容器中添加新元素，效率比 insert() 方法高。
insert()    向容器中添加新元素。
erase()    删除指定元素。
clear()    清空容器，即删除容器中存储的所有元素。
swap()    交换 2 个 unordered_map 容器存储的元素，前提是必须保证这 2 个容器的类型完全相等。
bucket_count()    返回当前容器底层存储元素时，使用桶（一个线性链表代表一个桶）的数量。
max_bucket_count()    返回当前系统中，unordered_map 容器底层最多可以使用多少桶。
bucket_size(n)    返回第 n 个桶中存储元素的数量。
bucket(key)    返回值为 key 的元素所在桶的编号。
load_factor()    返回 unordered_map 容器中当前的负载因子。负载因子，指的是的当前容器中存储元素的数量（size()）和使用桶数（bucket_count()）的比值，即 load_factor() = size() / bucket_count()。
max_load_factor()    返回或者设置当前 unordered_map 容器的负载因子。
rehash(n)    将当前容器底层使用桶的数量设置为 n。
reserve()    将存储桶的数量（也就是 bucket_count() 方法的返回值）设置为至少容纳count个元（不超过最大负载因子）所需的数量，并重新整理容器。
hash_function()    返回当前容器使用的哈希函数对象。

map:

函数名    功能
my_map.insert()或按照数组直接赋值    插入
my_map.find()    擦查找一个元素
my_map.clear()    清空
my_map.erase()    删除一个元素
my_map.size()    map的长度大小
my_map.begin()    返回指向map头部的迭代器
my_map.end()    返回指向map末尾的迭代器
my_map.rbegin()    返回一个指向map尾部的逆向迭代器
my_map.rend()    返回一个指向map头部的逆向迭代器
my_map.empty()    map为空时返回true
swap()    交换两个map,两个map中所有元素都交换

242.有效的字母异位词

题目链接/文章讲解/视频讲解：代码随想录

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。

示例 1: 输入: s = "anagram", t = "nagaram" 输出: true

示例 2: 输入: s = "rat", t = "car" 输出: false

说明: 你可以假设字符串只包含小写字母。

思路：

• 数组的值相互抵消
• 关键在于a-z与0-25的对应关系，索引为0-25的record数组的数值就代表相应字母的个数
• false条件就是字母个数出现不一致，即不为0

class Solution {
public:
    bool isAnagram(string s, string t) {
        int record[26] = {0};
        //a-z对应0-25
        for(int i = 0; i < s.size(); i++){
            record[s[i] - 'a']++; //出现哪个字母就把相应下标数组的值＋1
        }
        for(int i = 0; i < t.size(); i++){
            record[t[i] - 'a']--; //出现哪个字母就把相应下标数组的值-1
        }
        //不需要判断string大小
        for(int i = 0; i < 26; i++){
            if(record[i] != 0) //字母数量一直才能是0，有不一致就false
                return false;
        }
        return true;
    }
};

• 时间复杂度: O(n)
• 空间复杂度: O(1)

349. 两个数组的交集 

题目链接/文章讲解/视频讲解： 代码随想录

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

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

输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出：[9,4]
解释：[4,9] 也是可通过的

提示：

• 1 <= nums1.length, nums2.length <= 1000
• 0 <= nums1[i], nums2[i] <= 1000

方法一：数组

思路 ：如果出现了数组那就存为1，遍历判断是1后映射到哈希表

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        int hash[1005] = {0};
        unordered_set<int>result;
        for(int i = 0; i < nums1.size(); i++)
            hash[nums1[i]] = 1; //只需要知道出现过哪个元素，不需要知道多少
        for(int i = 0; i < nums2.size(); i++)
            if(hash[nums2[i]] == 1) //如果出现过那就插入
                result.insert(nums2[i]);
        return vector<int>(result.begin(),result.end());//固定语法
    }
};

• 时间复杂度: O(m + n)
• 空间复杂度: O(n)

方法二：set

思路：先把nums1的元素映射到哈希表上，就可以得到哈希表 

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result;
        unordered_set<int> nums_set(nums1.begin(),nums1.end()); //unordered_set原理是哈希表，可以去重
        for(int num : nums2){
            /*当我们使用std::set容器存储一组数字时，可以使用find()函数来查找是否存在特定的数字。在这种情况下，nums_set是一个set对象，存储了一些数字。


nums_set.find(num)将搜索nums_set中是否存在数字num。如果num存在于nums_set中，find()函数将返回一个指向该数字的迭代器；否则，它将返回nums_set.end()，即指向nums_set最后一个元素的下一个位置的迭代器。


所以，nums_set.find(num) != nums_set.end()这个条件语句的意思是，如果num在nums_set中存在，也就是find()函数返回的迭代器不等于nums_set的结尾迭代器，则执行相应的操作。


这段代码常用于判断一个数字是否出现在set容器中，以便根据这个判断作出进一步的操作。*/
            if(nums_set.find(num) != nums_set.end()) 
                result.insert(num);
        }
        return vector<int>(result.begin(),result.end());
    }
};

• 时间复杂度: O(mn)
• 空间复杂度: O(n)

 这段代码常用于判断一个数字是否出现在set容器中，以便根据这个判断作出进一步的操作。
            if(nums_set.find(num) != nums_set.end()) 

直接使用set 不仅占用空间比数组大，而且速度要比数组慢，set把数值映射到key上都要做hash计算，所以也不能盲目使用set。

202. 快乐数

 题目链接/文章讲解/视频讲解: 代码随想录 

目前为止唯一一道完完全全自己写出来的，让我快乐了

方法一：递归

class Solution {
public:
    bool isHappy(int n) {
        vector<int>temp;
        if(n == 1 || n == 7 || n == 10)
            return true;
        if(n/10 == 0)
            return false;
        int sum = 0;
        while(n){
            int tmp = n % 10;
            sum += tmp * tmp;
            n /= 10;
        }
        return isHappy(sum);
    }
};

方法二：哈希表 

class Solution {
public:
    // 取数值各个位上的单数之和
    int getSum(int n) {
        int sum = 0;
        while (n) {
            sum += (n % 10) * (n % 10);
            n /= 10;
        }
        return sum;
    }
    bool isHappy(int n) {
        unordered_set<int> set;
        while(1) {
            int sum = getSum(n);
            if (sum == 1) {
                return true;
            }
            // 如果这个sum曾经出现过，说明已经陷入了无限循环了，立刻return false
            if (set.find(sum) != set.end()) {
                return false;
            } else {
                set.insert(sum);
            }
            n = sum;
        }
    }
};

• 时间复杂度: O(logn)
• 空间复杂度: O(logn)

 1. 两数之和

 题目链接/文章讲解/视频讲解：代码随想录

 方法一：枚举

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        for(int i = 0; i < nums.size(); i ++){
            for(int j = i + 1; j < nums.size(); j++){
                if(nums[i] + nums[j] == target)
                    return {i, j};
            }
        }
        return {};
    }
};

复杂度分析

时间复杂度：O(N^2) )，其中 N是数组中的元素数量。最坏情况下数组中任意两个数都要被匹配一次。

空间复杂度：O(1)。

 方法二：map

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int,int>map;
        for(int i = 0; i < nums.size(); i++){
            //遍历当前元素，并在map中寻找是否有匹配的key
            //迭代器语法
            auto iter = map.find(target - nums[i]);
            if(iter != map.end())
                return {iter->second,i};
            //如果没找到匹配对，就把访问过的元素和下标加入到map中
            map.insert(pair<int,int>(nums[i], i));
        }
        return {};
    }
};

复杂度分析

时间复杂度：O(N)，其中 N是数组中的元素数量。对于每一个元素 x，我们可以 O(1) 地寻找 target - x。

空间复杂度：O(N)，其中 N 是数组中的元素数量。主要为哈希表的开销。