力扣打卡Day06 哈希表

学习了哈希表的实现原理、类别以及函数，然后才发现数组竟然也是一种哈希结构，区别就在于下标索引，所以unordered_set的查询效率也是O(1)。

一般哈希表用于判断元素是否出现在集合中，牺牲空间换取时间。还有一点就是set、unordered_set里的元素不重复这点也经常在做题中用到。

242.有效的字母异位词

看题解做的，主要是判断字母的出现次数，用哈希表

class Solution {
public:
    bool isAnagram(string s, string t) {
        if(s.length()!=t.length()) return false;
        unordered_map<char,int>map;
        for(char c:s) map[c]++;
        for(char c:t) map[c]--;
        for(auto v:map) {
            if(v.second!=0) return false;
        }
        return true;
    }
};

349.两个数组的交集

自己写的，感觉我的方法比官方题解看起来简洁不少，主要是用到了erase()，首先利用到了集合不重复的特性，然后再遍历第二个数组，查找相交的元素，再把集合里的元素给擦除，防止在答案里重复插入。

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        vector<int>ans;
        unordered_set<int>set;
        for(int i:nums1) {
            set.insert(i);
        }
        for(int i:nums2) {
            if(set.count(i)!=0) {
                ans.push_back(i);
                set.erase(i);
            }
        }
        return ans;
    }
};

202.快乐数

最气的是这道题之前考前端的期末考试里出过，但是一点思路都没有，看了别人的题解，发现可以之前做的那道查找循环的题，用快慢指针来做。

抄的别人的思路

class Solution {
public:
    int bitSquareSum(int n) {
        int sum = 0;
        while(n > 0)
        {
            int bit = n % 10;
            sum += bit * bit;
            n = n / 10;
        }
        return sum;
    }
    
    bool isHappy(int n) {
        int slow = n, fast = n;
        do{
            slow = bitSquareSum(slow);
            fast = bitSquareSum(fast);
            fast = bitSquareSum(fast);
        }while(slow != fast);
        
        return slow == 1;
    }
};

第二个方法就是哈希表了，就一直循环，如果数字重复了就返回false，如果数字没出现过就插入，如果数字为1就返回true。这题还有个难点就是针对一个数的单位数上的计算，大概就是利用取余数的原理，就可以算出来了。

class Solution {
public:
    int count(int n) {
        int sum = 0;
        while(n > 0)
        {
            int bit = n % 10;
            sum += bit * bit;
            n = n / 10;
        }
        return sum;
    }
    
    bool isHappy(int n) {
        unordered_set<int>set;
        while(1) {
            int sum = count(n);
            if(sum==1) return true;
            if(set.count(sum)) return false;
            else set.insert(sum);
            n=sum;
        }

    }
};

但是快慢指针的作者说不要用集合或者递归，参考：

注意：此题不建议用集合记录每次的计算结果来判断是否进入循环，因为这个集合可能大到无法存储；另外，也不建议使用递归，同理，如果递归层次较深，会直接导致调用栈崩溃。不要因为这个题目给出的整数是 int 型而投机取巧。

作者：金字塔下的小蜗牛
链接：https://leetcode.cn/problems/happy-number/solutions/21454/shi-yong-kuai-man-zhi-zhen-si-xiang-zhao-chu-xun-h/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

 1.两数之和

学到了哈希表的first、second的语法，first指的是索引。还有find()会返回一个迭代器，可以用::iterator或者是auto来定义。这一块感觉老忘。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int,int>map;
        for(int i=0;i<nums.size();i++){
            auto it = map.find(target-nums[i]);
            // first指向key，second指向值
            if(it!=map.end()) return {i, it->second};
            map[nums[i]]=i;
        }
        return {};   
    }
};