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

本文链接：https://blog.csdn.net/KINGjunT/article/details/128896086

第五天为周日，休息一天总结过去四天的成果

哈希表理论基础

哈希表能解决什么问题呢，一般哈希表都是用来快速判断一个元素是否出现集合里。
总结：当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法

常见的三种哈希结构

数组
set (集合)
map(映射)
在C++中，set 和 map 分别提供以下三种数据结构：

std::unordered_set底层实现为哈希表，std::set 和std::multiset 的底层实现是红黑树，红黑树是一种平衡二叉搜索树，所以key值是有序的，但key不可以修改，改动key值会导致整棵树的错乱，所以只能删除和增加。

std::unordered_map 底层实现为哈希表，std::map 和std::multimap 的底层实现是红黑树。同理，std::map 和std::multimap 的key也是有序的（这个问题也经常作为面试题，考察对语言容器底层的理解）。
当我们要使用集合来解决哈希问题的时候，优先使用unordered_set，因为它的查询和增删效率是最优的，如果需要集合是有序的，那么就用set，如果要求不仅有序还要有重复数据的话，那么就用multiset。

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

242.有效的字母异位词

题目连接 LC.242

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

注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。

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

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

思路：使用数组作为哈希表，数组通过下标可以找到对应位置的值。使用相对的ASCII码作为坐标索引；

遍历第一个字符串就让该位置的值加1；
遍历第二个字符串的时候，让对应ASCII值减一；
最后遍历一圈字母表，当遇到有不为0的时候，这表示不是字母异位词。
要注意：只有当数组范围比较小的时候才适合做哈希表。

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

总结：

并不一定要知道对应的ASCII码值，只需要知道相对的差值即可。
要熟悉哈希表的使用方法，不要搞混。

349. 两个数组的交集

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

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

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

思路：根据题意，查找一个元素在宁一个数组里是否出现，可以想到是一个用哈希表法来解决的问题。

根据结果中元素唯一，知道结果是去重后的，所以用unordered_set
根据限制条件考虑使用数组还是set集合

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        // 返回的是交集，不考虑结果顺序 去重
        unordered_set<int> ans;// 存放结果，之所以用set是为了给结果集去重
        unordered_set<int> num_set(nums1.begin(), nums1.end());
        
        for (int num : nums2) {
            if (num_set.find(num) != num_set.end()) {
                ans.insert(num);
            }
        }
        return vector<int>(ans.begin(), ans.end());
    }
};

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        // 返回的是交集，不考虑结果顺序 去重
        unordered_set<int> ans;
        int hash[1001] = {0};
        for(int i = 0; i < nums1.size(); i++) {
            hash[nums1[i]] = 1;
        }
        for (int j = 0; j < nums2.size(); j++) {
            if (hash[nums2[j]] == 1) {
                ans.insert(nums2[j]);
            }
        }
        return vector<int>{ans.begin(), ans.end()};
    }
};

总结：

要灵活读懂题意，怎么选择合适的数据结构是最重要的。
使用数组来做哈希的题目，是因为题目都限制了数值的大小。如果哈希值比较少、特别分散、跨度非常大，使用数组就造成空间的极大浪费。
不要让数据重复，所以选择unordered_set。

202. 快乐数

题目链接 LC.202

编写一个算法来判断一个数 n 是不是快乐数。

「快乐数」 定义为：
对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
如果这个过程 结果为 1，那么这个数就是快乐数。
如果 n 是 快乐数 就返回 true ；不是，则返回 false

在这里插入图片描述
思路：通过快乐数的定义，无限循环但始终变不到 1，可以推出在求和的过程中，出现了重复的值。

当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法了。
所以这道题目使用哈希法，来判断这个sum是否重复出现，如果重复了就是return false，否则一直找到sum为1为止。
判断sum是否重复出现就可以使用unordered_set。

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 a = getSum(n);
            if (a == 1) {
                return true;
            }
			// 如果出现循环，则返回false
            else if (set.find(a) != set.end()) {
                return false;
            } else {
                set.insert(a);
            } 
            n = a;
        }
    }
};

总结：本题主要要想到以下的情况

最终会得到 1。
最终会进入循环。
值会越来越大，最后接近无穷大。
但是实际上第三种不会出现，因为9999999999999 的下一个也只是1053，会一步步失位到四位三位，如果不是快乐数，那么会进入一个类似环形链表的情况。
其次，我们要知道怎么取得某个数的个位十位百位，如和对取数值各个位上的单数操作

n % 10     取得最后单数
n  / 10  	抛弃最后的单数
while (n) {
	sum += (n % 10) * (n % 10);
    n /= 10;
}

1. 两数之和

题目链接 LC.1

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出和为目标值 target 的那两个整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。

示例 1：
输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

示例 2：
输入：nums = [3,2,4], target = 6
输出：[1,2]

思路：查找一个元素在集合中是否出现，首先想到哈希法。其次通过map容器的查找方法，找到目标，返回相应的坐标即可。
要注意

为什么要选择unordered_map，而不是其他。需要使用 key value结构来存放，key来存元素，value来存下标，那么使用map正合适。
这道题目中并不需要key有序，选择std::unordered_map 效率更高！
遍历数组的时候，只需要向map去查询是否有和目前遍历元素比配的数值，如果有，就找到的匹配对，如果没有，就把目前遍历的元素放进map中，

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        // 查找一个元素在集合中是否出现，使用哈希法
        // key 是 数值    value 是 下标
        unordered_map<int, int> map;
        //遍历数组，当出现有元素相加位target的时候，返回对应下标
        for (int i = 0; i < nums.size(); i++) {
            int s = target - nums[i]; 
            //在map里面找到是否出现过 s
            if (map.find(s) != map.end()) {
                //如果出现了，返返回对应的下标数组
                return vector<int>{map.find(s)->second, i};
            }
            map.insert(pair<int, int>{nums[i], i});
        }
        return {};
    }
};