代码随想录Day6哈希表理论基础 242.有效的字母异位词349. 两个数组的交集202. 快乐数 1. 两数之和

哈希表理论基础

哈希表又叫做散列表：哈希表是根据关键码的值而直接进行访问的数据结构。

哈希表中的关键码就是数组的的索引下标，然后通过下标直接访问数组中的元素，如下图所示

一般哈希表都是用来快速判断一个元素是否出现集合里。

例如要查询一个名字是否在这所学校里。

要枚举的话时间复杂度是O(n)，但如果使用哈希表的话， 只需要O(1)就可以做到。

我们只需要初始化把这所学校里学生的名字都存在哈希表里，在查询的时候通过索引直接就可以知道这位同学在不在这所学校里了。

将学生姓名映射到哈希表上就涉及到了hash function ，也就是哈希函数。

哈希函数

哈希函数，把学生的姓名直接映射为哈希表上的索引，然后就可以通过查询索引下标快速知道这位同学是否在这所学校里了。

哈希函数如下图所示，通过hashCode把名字转化为数值，一般hashcode是通过特定编码方式，可以将其他数据格式转化为不同的数值，这样就把学生名字映射为哈希表上的索引数字了。

如果hashCode得到的数值大于 哈希表的大小了，也就是大于tableSize了，怎么办呢？

此时为了保证映射出来的索引数值都落在哈希表上，我们会在再次对数值做一个取模的操作，这样我们就保证了学生姓名一定可以映射到哈希表上了。

此时问题又来了，哈希表我们刚刚说过，就是一个数组。

如果学生的数量大于哈希表的大小怎么办，此时就算哈希函数计算的再均匀，也避免不了会有几位学生的名字同时映射到哈希表 同一个索引下标的位置。

接下来哈希碰撞登场

哈希碰撞

如图所示，小李和小王都映射到了索引下标 1 的位置，这一现象叫做哈希碰撞。

一般哈希碰撞有两种解决方法， 拉链法和线性探测法。

拉链法：

刚刚小李和小王在索引1的位置发生了冲突，发生冲突的元素都被存储在链表中。 这样我们就可以通过索引找到小李和小王了

（数据规模是dataSize， 哈希表的大小为tableSize）

其实拉链法就是要选择适当的哈希表的大小，这样既不会因为数组空值而浪费大量内存，也不会因为链表太长而在查找上浪费太多时间。

线性探测法

使用线性探测法，一定要保证tableSize大于dataSize。 我们需要依靠哈希表中的空位来解决碰撞问题。

例如冲突的位置，放了小李，那么就向下找一个空位放置小王的信息。所以要求tableSize一定要大于dataSize ，要不然哈希表上就没有空置的位置来存放 冲突的数据了。如图所示：

常见的三种哈希结构

当我们想使用哈希法来解决问题的时候，我们一般会选择如下三种数据结构。

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

在C++中，set 和 map 分别提供以下三种数据结构，其底层实现以及优劣如下表所示：

当我们要使用集合来解决哈希问题的时候，优先使用unordered_set，因为它的查询和增删效率是最优的，如果需要集合是有序的，那么就用set，如果要求不仅有序还要有重复数据的话，那么就用multiset。

那么再来看一下map ，在map 是一个key value 的数据结构，map中，对key是有限制，对value没有限制的，因为key的存储方式使用红黑树实现的。

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

但是哈希法也是牺牲了空间换取了时间，因为我们要使用额外的数组，set或者是map来存放数据，才能实现快速的查找。

如果在做面试题目的时候遇到需要判断一个元素是否出现过的场景也应该第一时间想到哈希法！

242.有效的字母异位词

思路：判断两个字符串所包含的字母是否完全一致，这可以使用哈希表中的数组的方式记录一下每个字母的频率
重新映射到数组上面，最终得到的一个新数组看看数组中的元素是否全为0，如果全部为0的话，则这两个字符串就是字母异位词。

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

这里只用注意小写字母就行所以只需要去求相对位置的就行；

349. 两个数组的交集

第一种写法还跟上题一样使用hash表中的数组结构，因为数组中的值的大小都小于1000所以数组的空间都不是很大。同时使用数组元素的运行访问效率会更加的高效。

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result_set;//进行去重操作，这个数据结构所保存的结果是不包含重复
        int hash[1002]={0};
        for(num:nums1)//C++11中的新特性可以对vector等这种向量进行使用简洁高效
        {
            hash[num]=1;
		}
        for(num:nums2)
        {
            if(hash[num]==1)
            {
                result_set.insert(num);
			}
		}
        return vector<int> (result_set.begin(),result_set.end());//将这种数据结构最后复制为整型的数据向量。
    }
};

如果给的数值的太大的话，使用数组的方法的话不太合适，这时候我们要考虑使用unordered_set中的set结构。

class Solution
{
	public:
    	vector<int> intersection(vector<int>& nums1,vector<int>& nums2)
        {
            unordered_set<int> result_set;
            nums1_set=unordered_set<int>(nums1.begin(),nums1.end());
            for(int num:nums2)
            {
                if(nums1_set.find(num)!=nums1_set.end())
                {
                    result_set.insert(num);
				}
			}
            return vector<int>(result_set.begin(),result_set.;
        }
};

202. 快乐数

根据前面的我们知道如果我们想快速地找到是否存在一个元素，我们就要采取哈希表的数据结构，根据本道题目我们需要先知道一个数字各个位置上的数字的平方和，直到为1时时快乐数，如果一直循环的话则不是；

class Solution
{
	public:
    	int getsum(int n)//主要是计算当前值的各个位置上数字的平方和
        {
            int sum=0;
            while(n)
            {
                sum+=(sum%10)*(sum%10);
                n=n/10；
			}
            return sum;
		}
    bool isHappy(int n)
    {
        unordered_set<int> set;//建立一个哈希表来判断是否存在sum==1；
        while(1)
        {
            int sum=getsum(n);
            if(sum==1)
            {
                return true;
			}
            if(set.find(sum)!=set.end())//如果当前的值之前已经存在过的话则返回
            {
                return false;
			}
            else
            {
                set.insert(sum);//没有存在的话将当前值插入哈希表。
			}
		}
	}
};

1. 两数之和

第一种解法就是遍历法时间复杂度可能是最高的，此时对于这种题目我们也可以用哈希表来进行解决。

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