代码随想录算法训练营Day.6 哈希表 part01 | 有效的字母异位词 两个数组的交集 快乐数 两数之和

哈希表

242.有效的字母异位词

今天主题是哈希表，所以肯定先用hash解决，这里用的是unordered_map，是不是字母异位词其实就是判断组成单词的字母类型和数量是否一致。

class Solution {
public:
    bool isAnagram(string s, string t) {
        std::unordered_map<char, int> map_st;
        std::unordered_map<char, int>::iterator it;
        for(char c : s)
        {
            if((it = map_st.find(c)) == map_st.end())
            {
                map_st.insert({c,1});
            }
            else
            {
                map_st[c] = it->second + 1;
            }
        }
        for(char c : t)
        {
            if((it = map_st.find(c)) == map_st.end())
            {
                return false;
            }
            else
            {
                if(it -> second == 0) return false;
                map_st[c] = it->second - 1;
                if(it -> second == 0) map_st.erase(it);
            }
        }
        if(map_st.size() > 0) return false;
        return true;
    }
};

但是其实用数组也是哈希方法的使用：

class Solution {
public:
    bool isAnagram(string s, string t) {
        int map[26]{0};
        if(s.size() != t.size()) return false; // 剪枝
        for(char c : s)
        {
            map[c - 'a'] ++;
        }
        for(char c : t)
        {
            map[c - 'a'] --;
            if(map[c-'a'] < 0) return false;
        }
        for(int i : map)
        {
            if(i > 0) return false;
        }
        return true;
    }
};

349.两个数组的交集

非常简单的set的使用：

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        std::unordered_set<int> num_set;
        std::unordered_set<int> num_res;
        vector<int> res;
        for(int key : nums1){
            num_set.insert(key);
        }
        for(int key : nums2){
            if(num_set.find(key) != num_set.end()){
                num_res.insert(key);
            }
        }
        for(int key : num_res){
            res.push_back(key);
        }
        return res;
    }
};

202.快乐数

这道题，一个是考察对每个数字的各位的计算，一个就是判断是否循环，很明显循环判断可以用set实现：

class Solution {
public:
    bool isHappy(int n) {
        int res = n;
        int temp{0};
        // 添加 set 判断循环
        unordered_set<int> set_loop;
        while(res != 1)
        {
            temp = res;
            if(set_loop.find(temp) != set_loop.end()) return false;
            else set_loop.insert(temp);
            res = 0;
            while(temp != 0)
            {
                res += (temp%10) * (temp%10);
                temp /= 10;
            }
        }
        return true;
    }
};

1.两数之和

一个简单的思想，知道target知道nums[i]我只需要找是否出现target - nums[i]即可：

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