代码随想录训练营第六天——有效的字母异位词，两个数组的交集，快乐数，两数之和

哈希表基础理论

常见三种哈希结构

• 数组
• set（集合）
• map（映射）
  在C++中，set 和 map 分别提供以下三种数据结构，其底层实现以及优劣如下表所示：
  
  
• 当使用集合解决哈希问题时，优先使用unordered_set，因为它的查询和增删效率是最优的，如果需要集合是有序的，用set，如果要求不仅有序还要有重复数据的话，用multiset。
• map 是一个key value 的数据结构，map中，对key有限制，对value没有限制，因为key的存储方式使用红黑树实现的。
• 当我们需要查询一个元素是否出现过，或者一个元素是否在集合里的时候，就要第一时间想到哈希法。但是哈希法是牺牲了空间换取了时间，因为需要要使用额外的数组，set或者是map存放数据，才能实现快速的查找。

leetcode 242.有效的字母异位词

题目链接：有效的字母异位词
本题采用数组作为哈希表：
定义一个数组记录字符串s里字符出现的次数。字符通过与字符a的相对值映射到数组也就是哈希表的索引下标上，字符a映射为下标0，字符z映射为下标25。遍历字符串s时，将 s[i] - ‘a’ 所在元素+1，检查字符串t中是否出现了这些字符，同样在遍历字符串t的时候，对t中出现的字符映射哈希表索引上的数值-1。最后，如果record数组有的元素不为零0，说明字符串s和t一定字符数量不一致，return false。
如果record数组中所有元素都为0，说明字符串s和t是字母异位词，return true。

class Solution {
public:
    bool isAnagram(string s, string t) {
        int record[26]={0};
        for(int i=0;i<s.size();i++)
        {
            // 通过字符的相对值映射
            record[s[i]-'a']++;
            }
        for(int j=0;j<t.size();j++)
        {
            record[t[j]-'a']--;
            }
        for(int k=0;k<26;k++)
        {
            if(record[k]!=0)  // record数组如果有的元素不为零0，说明字符串s和t一定是谁多了字符或者谁少了字符。
            {
                return false;
            }
        }
       return true;    // record数组所有元素都为零0，说明字符串s和t是字母异位词
    }
};

时间复杂度：O(n)
空间复杂度：定义了一个常量大小的辅助数组，所以空间复杂度为O(1)

leetcode 349.两个数组的交集

题目链接：两个数组的交集
本题使用unordered_set。

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> nums;   // 存放结果，之所以用set是为了给结果集去重
        unordered_set<int> nums1_set(nums1.begin(),nums1.end());
        for(int num:nums2)
        {
            if(nums1_set.find(num)!=nums1_set.end())    // 判断nums2的元素 是否在nums_set里又出现过
            {
                nums.insert(num);
            }
        }
        return vector<int>(nums.begin(),nums.end());   
    }
};

时间复杂度：O(m+n)
空间复杂度：O(m+n)
注意：set 占用空间比数组大，速度要比数组慢，set把数值映射到key上都要做hash计算。在数据量大的情况下，耗时的差距很明显，因此如果能用数组最好用数组

leetcode 202.快乐数

题目链接：快乐数
本题算法分为两部分：

• 给一个数字 n，计算下一个数字是多少
• 按照一系列的数字判断我们是否进入了一个循环。

方法一：使用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)写无无限循环
        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);    //set插入数值
            }
            n = sum;
        }
    }
};

时间复杂度：O(logn)
空间复杂度：O(logn)

方法二：使用快慢指针

反复计算平方和得到的值可以看作一个链表，则判断平方和是否重复出现相当于判断一个链表是否有环。
设定慢指针在链表中前进 1 个节点，快指针前进 2 个节点：

• 如果 n 是一个快乐数，即没有循环，那么快指针会比慢指针先到达数字 1。
• 如果 n 不是一个快乐数，最终快指针和慢指针将在同一个数字上相遇。

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) {
        int slow = n, fast = n;
        do{
            slow = getSum(slow);      //慢指针计算一次
            fast = getSum(fast);   
            fast = getSum(fast);    //快指针计算两次
        }while(slow != fast);
        return slow == 1;
    }
};

时间复杂度：O(logn)
空间复杂度：O(1)

leetcode 1.两数之和

题目链接：两数之和
数组和set来做哈希法的局限：

• 数组的大小是受限制的，如果元素很少，而哈希值太大会造成内存空间的浪费。
• set是一个集合，里面放的元素只能是一个key。
  本题不仅要判断值是否存在而且要记录值的下标，set不能使用，因此本题用map，存放访问过的元素。 map中的存储结构为 {key：数组元素，value：数组对应的下标}。

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};
            }
            else
            {
                map.insert(pair<int,int>(nums[i],i));  //使用pair插入
                //map[nums[i]]=i;    //直接赋值
            }
        }
        return {};
    }
};

时间复杂度：O(n)
空间复杂度：O(n)