力扣哈希表简单练习

力扣哈希表

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

242. 有效的字母异位词

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

349. 两个数组的交集

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result_set;
        int hash[1002]={0};
        for(int num:nums1)
        {
            hash[num]=1;
        }
        for(int num:nums2)
        {
            if(hash[num]==1) result_set.insert(num);
        }
        return vector<int>(result_set.begin(), result_set.end());
    }
};

202. 快乐数

方法1：快慢双指针

仔细读题，可知这个题会有两种结果，在执行未知次计算后找出循环：“快指针” 每次走两步，“慢指针” 每次走一步，当二者相等时，即为一个循环周期。此时，判断是不是因为 1 引起的循环，是的话就是快乐数，否则不是快乐数

class Solution {
public:
    int bitsum(int n) {
        int sum = 0;
        while (n) {
            int t = n % 10;
            sum += t * t;
            n = n / 10;
        }
        return sum;
    }
    bool isHappy(int n) {
        int slow = n, fast = bitsum(n);
        while (slow != fast) {
            slow = bitsum(slow);
            fast = bitsum(bitsum(fast));
        }
        if (slow == 1)
            return true;
        else
            return false;
    }
};

方法2：哈希

sum会重复出现，既然要找一个数之前出现过没有，就要利用哈希表

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

1. 两数之和

利用哈希表存储之前遍历的数据

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int,int> hash;
        for(int i=0;i<nums.size();i++)
        {
            auto it =hash.find(target-nums[i]);
            if(it!=hash.end())
            {
                return {it->second,i};
            }
            hash[nums[i]]=i;    //插入+修改
        }
        return {};
    }
};