代码随想录Day6 | 242.有效的字母异位词，349. 两个数组的交集 ，202. 快乐数，1. 两数之和

目录

242.有效的字母异位词

349. 两个数组的交集

方法一：哈希表（数组）

方法二：哈希表（set）

202. 快乐数

1. 两数之和

方法一：暴力求解

方法二：哈希map

---

 

242.有效的字母异位词

        数组其实就是简单的哈希表，比较巧妙的是仅使用了一个数组，把"a-z"26个字符映射到数组的索引下标,。先遍历一遍string s，若在string s中出现过的字母，数组会在相应位置显示1。再遍历一遍string t，对t中出现的字符映射到数组中-1。

        如果最后结果数组中元素为全0，则为有效字母异位词，反之则不是。

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

349. 两个数组的交集

方法一：哈希表（数组）

        定义一个元素数略大于1000（因为数组元素值不超过1000）的数组，同时定义一个哈希set，目的是存放结果（使用set有个好处，能自动去重）。先将nums1遍历一遍，将nums1中出现的值在哈希数组里做记录（对应索引处数值对应变为1）。再遍历一遍nums2，如果nums2的数组元素与nums1中的值相同时，insert进result_set。

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int>result_set;
        int hash[1005] = { 0 };
        for (int i = 0; i < nums1.size(); i++) {
            hash[nums1[i]] = 1;
        }
        for (int i = 0; i < nums2.size(); i++) {
            if (hash[nums2[i]] == 1) {
                result_set.insert(nums2[i]);
            }
        }
        return vector<int>(result_set.begin(), result_set.end());
    }
};
//哈希数组

方法二：哈希表（set）

        定义两个哈希set，一个存放结果，另一个存放nums1。读取nums2的元素，如果他在存放nums1的set中出现过，则insert进result。最后返回以向量的形式返回reslut。

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) {
            if (nums_set.find(num) != nums_set.end()) {
                result_set.insert(num);
            }
        }
        return vector<int>(result_set.begin(), result_set.end());
    }
};

202. 快乐数

        首先定义一个函数，用来计算一个数每个位置上的数字的平方和sum。再定义一个unordered_set,用来存放sum值。

判定方式：

        如果sum=1，return true。

        如果sum这个值在set里出现过，则表示陷入无限循环，立刻return false。

        如果sum没有出现过，则insert进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;
            }
            if (set.find(sum)!=set.end()) {
                return false;
            }
            else {
                set.insert(sum);
            }
            n = sum;
        }
    }
};

1. 两数之和

方法一：暴力求解

两个for循环嵌套

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        for (int i = 0; i < nums.size(); i++) {
            int num = target - nums[i];
            for (int j = i + 1; j < nums.size(); j++) {
                if (nums[j] == num) {
                    return { i,j };
                }
            }
        }
        return {};
    }
};

方法二：哈希map

        定义一个map，目的是存放我们访问过的元素。map中的存储结构为 {key：数组元素，value：数组元素对应的下标}。遍历数组的时候，向map去查询是否有和目前遍历元素匹配的数值，如果有，就找到了匹配对，输出对应的数值和下标。如果没有，就把目前遍历的元素放进map中。

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 iter = map.find(target - nums[i]);
            if (iter != map.end()) {
                return { iter->second,i };
            }
            map.insert(pair<int, int>(nums[i], i));
        }
        return {};
    }
};