算法 第6天 哈希表1

有效的字母异位词

1. 242.有效的字母异位词

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

class Solution {
public:
    bool isAnagram(string s, string t) {
        int record[26] = {0};
        for (int i = 0; i < s.size(); i++) {
            // 并不需要记住字符a的ASCII，只要求出一个相对数值就可以了
            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) {
                // record数组如果有的元素不为零0，说明字符串s和t 一定是谁多了字符或者谁少了字符。
                return false;
            }
        }
        // record数组所有元素都为零0，说明字符串s和t是字母异位词
        return true;
    }
};

• 使用了哈希表中的数组，由于只有26位，所以直接数组，核心点：

record[s[i] - 'a']++;

直接对应每个字母进行计算。

349. 两个数组的交集（Set作哈希表）

• set 概念：重要的是插入和查找,排序（为了去重）

    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result_set; // 存放结果，之所以用set是为了给结果集去重
        unordered_set<int> nums_set(nums1.begin(), nums1.end());
    }

#include <iostream>
#include <set>

int main() {
    std::set<int> s = {1, 2, 3, 4, 5};

    // 插入元素
    s.insert(6);
    s.insert(3); // 重复元素，不会插入

    // 删除元素
    s.erase(2);

    // 查找元素
    auto it = s.find(4);
    if (it != s.end()) {
        std::cout << "Found: " << *it << std::endl;
    } else {
        std::cout << "Not found" << std::endl;
    }

    // 检查元素是否存在
    if (s.count(5) > 0) {
        std::cout << "5 is in the set" << std::endl;
    } else {
        std::cout << "5 is not in the set" << std::endl;
    }

    // 遍历元素
    for (const auto& elem : s) {
        std::cout << elem << " ";
    }
    std::cout << std::endl;

    // 获取大小
    std::cout << "Size: " << s.size() << std::endl;

    // 清空集合
    s.clear();
    std::cout << "Size after clear: " << s.size() << std::endl;

    return 0;
}

题解：
先对一个数组的内容进行排序去重，然后用另一个数组的内容这扎个数组中有没有出现过，出现过就添加进去，然后结果再排序去重复。

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result_set; // 存放结果，之所以用set是为了给结果集去重
        unordered_set<int> nums_set(nums1.begin(), nums1.end());
        for (int num : nums2) {
            // 发现nums2的元素 在nums_set里又出现过
            if (nums_set.find(num) != nums_set.end()) {
                result_set.insert(num);
            }
        }
        return vector<int>(result_set.begin(), result_set.end());
    }
};

第202题. 快乐数

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

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

• 简体秘籍：获取一个数每一位的方法：

	    int get_sum(int n){
        int sum=0;
        while (n){
            sum=sum+(n%10)*(n%10);
            n=n/10;
        }
        return sum;

然后再用set方法find以前有没有这个数，有的话就返回错误，因为开始循环，就不是快乐数了

class Solution {
public:
    int get_sum(int n){
        int sum=0;
        while (n){
            sum=sum+(n%10)*(n%10);
            n=n/10;
        }
        return sum;
    }
    bool isHappy(int n) {
        unordered_set<int> res;
        while(1){

            int sum = get_sum(n);
            
            if(sum==1) return true;
            else{
                if(res.find(sum)!=res.end()){
                    return false;
                }
                else{
                    res.insert(sum);
                }
            }   
        n=sum;
        }
    }
    
};

1. 两数之和

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

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9

所以返回 [0, 1]

• map的常见语法：

    std:unordered_map<int,int> res; //定义

    for(int i=0;i<nums.size();i++){
        auto iter = res.find(target-nums[i]);
        if(iter!=res.end()){//不等于就是找到了
        }

• 结题秘籍：不用暴力法，用unordered_map,key作为数组中的值，寻找对应的数，数组下标作为val，然后返回两个下标。

using namespace std;
// @lc code=start
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};
//                 }
//             }
//         }
//         // 如果没有找到符合条件的元素，返回一个空的 vector
//         return {};

//哈希表map
    std:unordered_map<int,int> res;

    for(int i=0;i<nums.size();i++){
        auto iter = res.find(target-nums[i]);
        if(iter!=res.end()){//不等于说明找到了
            return {iter->second,i};
        }
        res.insert(pair<int,int>(nums[i],i));
    }
    return {};
    }
};