算法训练第六天 | LeetCode 242、349、202、1

当我们需要查询一个元素是否出现过，或者一个元素是否在集合里的时候，就要第一时间想到哈希法。

LeetCode242

题目简析：给定两个字符串判断两个字符串中的字符以及对应数量是否相同

思路：定义一个数组，名为record,大小26，初始化为0

记录字符串s里字符出现的次数，需要字符映射到数组也就是哈希表的索引下标上

字符映射到哈希表的索引下标上

字符a到字符z的ASCII是26个连续的数值，所以字符a映射为下标0，相应的字符z映射为下标25。

遍历字符串时，将s[i]-'a’的元素加一，无需记住‘a’的ASCII码

我们可以求得相对数值

比如“aee”

s[1]=‘a’s[2]='e';s[3]='e'

a的ascii码转十进制是97，e的ascii码转十进制是101，差4

由此我们得知，s[i]-'a’便为s[i]在record数组中的下标、索引

遍历下串t时，将t[i]-'a'的元素减一，最后减为0

class Solution {
public:
    bool isAnagram(string s, string t) {
        int record[26]={0};
        while(s.size()--){
            record[s[i]-'a']++;

        }
        while(t.size()--){
            record[s[i]-'a']--;

        }
        for(int i=0;i<26;i++){
            if(record[i]!=0){
                return false;
            }
        }
        return true;
    }
};

LeetCode 349

题目简析：给定两个数组 nums1 和 nums2 ，返回 它们的交集

哈希数据结构：unordered_set,主要功能去重

用来解决没有限制数值大小（哈希表，不可用数组），输出结果中的每个元素一定是唯一的，也就是说输出的结果的去重的， 同时可以不考虑输出结果的顺序的问题

哈希值比较少、特别分散、跨度非常大，使用数组会造成空间上的浪费

std::set和std::multiset底层实现都是红黑树，std::unordered_set的底层实现是哈希表， 使用unordered_set 读写效率是最高的，并不需要对数据进行排序，而且还不要让数据重复，所以选择unordered_set

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int>result_set;
        unordered_set<int>nums_set(nums1.begin(),nums1.end());
        for(int num:nums2){//迭代，对于nums2的每一个元素num
        //遍历nums的元素，每次把值赋给定义的变量num
        //等价于for(int i=0;i<nums2.size();i++)
            if(nums_set.find(num)!=nums_set.end()){//查找操作
                result_set.insert(num);//插入操作
            }
        }
        return vector<int>(result_set.begin(),result_set.end());
    
    }
};

数组做法

力扣改了 题目描述 和 后台测试数据，增添了 数值范围：

• 1 <= nums1.length, nums2.length <= 1000

• 0 <= nums1[i], nums2[i] <= 1000

所以就可以 使用数组来做哈希表了， 因为数组都是 1000以内的。

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result_set; // 存放结果，之所以用set是为了给结果集去重
        int hash[1005] = {0}; // 默认数值为0
        for (int num : nums1) { // nums1中出现的字母在hash数组中做记录
            hash[num] = 1;//将nums1的哈希数组下标都设为1
        }
        for (int num : nums2) { // nums2中出现话，result记录
            if (hash[num] == 1) {//说明nums2中元素在nums1中出现过
                result_set.insert(num);
            }
        }
        return vector<int>(result_set.begin(), result_set.end());
    }
};

LeetCode 1

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

MAP数据结构

需要使用 key value结构来存放，key来存元素，value来存下标.

std::unordered_map 底层实现为哈希表，std::map 和std::multimap 的底层实现是红黑树。

思路：map目的用来存放我们访问过的元素，因为遍历数组的时候，需要记录我们之前遍历过哪些元素和对应的下标，这样才能找到与当前元素相匹配的（也就是相加等于target）

在遍历数组的时候，只需要向map去查询是否有和目前遍历元素比配的数值，如果有，就找到的匹配对，如果没有，就把目前遍历的元素放进map中，因为map存放的就是我们访问过的元素。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        std::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中寻找是否有匹配的key
            map.insert(pair<int,int>(nums[i],i));
        }
        return{};
    }


};

LeetCode 202快乐数（待补充）

题目简析：编写一个算法来判断一个数 n 是不是快乐数

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

输入：19

输出：true

解释：

1^2 + 9^2 = 82

8^2 + 2^2 = 68

6^2 + 8^2 = 100

1^2 + 0^2 + 0^2 = 1

思路：求和的过程中，sum会重复出现

判断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 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;
        }
    }
};

出现问题：对单数操作不熟悉