Day06哈希表基础，unordered_set，unordered_map

听起来似乎很高大上，其实一点儿也不。所谓哈希表，最突出的特征应该是根据码值迅速找到对应数据。例如数组，就是最常用的一种哈希表。

哈希函数，其实就是一种映射关系，一般是一一对应。如果存在多对一，那就是哈希碰撞情况，可以用拉链法（如下图），用链表存储，或者线性探测法，即哈希表多些空位，遇到冲突就向下找下一个空位即可。

常见三种哈希结构：

• 数组
• set （集合）
• map(映射)

具体容器后面用到再整理。

刷题刷题！

242.有效的字母异位词

这题好简单！定义两个int 数组，分别记录两个字符串每个字母出现次数，然后遍历0-25一一比较就行了，只要有一个不等就输出false。一把过，代码如下：

class Solution {
public:
    bool isAnagram(string s, string t) {
        int a[30]={},b[30]={};
        for(int i=0;i<s.length();i++)
        {
            int k=s[i]-'a';
            a[k]++;
        }
        for(int i=0;i<t.length();i++)
        {
            int m=t[i]-'a';
            b[m]++;
        }
        bool f=true;
        for(int i=0;i<26;i++)
        {
            if(a[i]!=b[i])
            {
                f=false;
                break;
            }
        }
        return f;
    }
};

349.两个数组的交集

这道题也是两个数组标记，遇到两个数组下标都被标记就把这个下标放进新数组。太简单了，也是直接过

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        vector<int>ans;
        int a[1005]={},b[1005]={};
        for(int i=0;i<nums1.size();i++)a[nums1[i]]=1;
        for(int i=0;i<nums2.size();i++)b[nums2[i]]=1;
        for(int i=0;i<=1000;i++)if(a[i]&&b[i])ans.push_back(i);
        return ans;
    }
};

202.快乐数

这道题判断是否死循环的关键就是是否出现重复数字。由于数据范围很大，运算过程中出现的数据也会遍布整个int，所以数组肯定不行，只能用集合了。

unordered_set用法：

无序集合(unordered_set)是一种使用哈希表实现的无序关联容器，其中键被哈希到哈希表的索引位置，因此插入操作总是随机的。无序集合上的所有操作在平均情况下都具有常数时间复杂度O(1)，但在最坏情况下，时间复杂度可以达到线性时间O(n)，这取决于内部使用的哈希函数，但实际上它们表现非常出色，通常提供常数时间的查找操作。

常用方法

• size()和empty():用于获取大小和集合是否为空
• find():用于查找键
• insert()和erase():用于插入和删除元素

如果集合中不存在某个键，find()函数会返回一个指向end()的迭代器，否则会返回指向键位置的迭代器。

根据这些基础用法已经够写出这道题了，代码如下

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

1.两数之和

这道题的范围是1e4，暴力枚举严格来说复杂度并不是O(n^2)，毕竟要避免重复。所以暴枚的时间应该还是会控制在1s以内，暴力出奇迹，直接过：

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

然而我是要练习哈希表，所以这道题应该用最合适的map来做，把复杂度降低到O(n)。考虑到方便引用，最好是用unordered_map

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

一些用法（end()的用法跟set一样）：