代码随想录算法训练营第六天| 哈希表part01

242.有效的字母异位词

https://leetcode.cn/problems/valid-anagram/
给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。
示例 1:
输入: s = “anagram”, t = “nagaram”
输出: true

class Solution {
public:
    bool isAnagram(string s, string t) {
        unordered_map<char, int> m;
        for (char c : s) { 
            // 遍历字符串 s，统计其中每个字符出现的次数，并将其存储在 map 中
            m[c]++;
        }
        for (char c : t) { 
            // 遍历字符串 t，统计其中每个字符出现的次数，对应在map 中计数减 1
            m[c]--;
        }
        for (auto [c, n] : m) {
            // 遍历 map 中的键值对，如果有计数不为 0，表示 s 和 t 中存在出现次数不同的字符
            if (n != 0) {
                return false;
            }
        }
        return true;
    }
};

349. 两个数组的交集

https://leetcode.cn/problems/intersection-of-two-arrays/
给定两个数组 nums1 和 nums2 ，返回 它们的 交集。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。
示例 1：
输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2]

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> s;
        for (int num : nums1) { // 遍历 nums1，将 nums1 中的元素存储到 set 容器中
            if (s.count(num) == 0) { // 查找键值出现的次数，结果只能为 0 或 1
                s.insert(num);
            }
        }
        vector<int> ans;
        for (int num : nums2) {
            if (s.count(num)) { 
                ans.emplace_back(num);
                s.erase(num); // 避免 nums2 中的重复元素，再次输出
            }
        }
        return ans;
    }
};

利用 set中每个元素的值都唯一 的特点

202. 快乐数

https://leetcode.cn/problems/happy-number/
编写一个算法来判断一个数 n 是不是快乐数。
「快乐数」 定义为：
对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
如果这个过程 结果为 1，那么这个数就是快乐数。
如果 n 是 快乐数 就返回 true ；不是，则返回 false 。
示例 1：
输入：n = 19
输出：true
解释：
1^2 + 9^2 = 82
8^2 + 2^2 = 68
6^2 + 8^2 = 100
1^2 + 0^2 + 0^2 = 1

class Solution {
public:
    int squareSum(int n) {
        int sum = 0;
        while (n) {
            sum += (n%10) * (n%10);
            n /= 10;
        }
        return sum;
    }
    bool isHappy(int n) {
        unordered_set<int> s;
        //如果平方和得到的新数字出现过，平方和的计算就会进入循环，那么这样就始终便不到 1
        while (s.count(n) == 0) {
            s.insert(n);
            //计算 n 的平方和, 更新 n
            n = squareSum(n);
            if (n == 1) {
                return true;
            }
        }
        return false;
    }
};

1. 两数之和

https://leetcode.cn/problems/two-sum/
给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。
暴力解法

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

哈希表

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int,int> m;
        // 一次遍历得到 target 和 nums[i] 的差值, 
        for (int i = 0; i < nums.size(); ++i) {
            int diff = target - nums[i];
            m[diff] = i;
        }
        // 再次遍历 判断差值是否存在于原数组中
        for (int i = 0; i < nums.size(); ++i) {
            if (m.find(nums[i]) != m.end()) {
                if (i != m[nums[i]]) {
                    return {i, m[nums[i]]};
                }
            }
        }
        return {};
    }
};

简化

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int,int> m;
        for (int i = 0; i < nums.size(); ++i) {
            int diff = target - nums[i];
            if (m.find(diff) != m.end()) {
                return {i, m[diff]};
            }
            m[nums[i]] = i;
        }
        return {};
    }
};