代码随想录算法训练营第6天 | 哈希表理论基础 、242.有效的字母异位词 、349. 两个数组的交集 、202. 快乐数、1. 两数之和

哈希表理论基础

哈希表

哈希表是根据关键码的值而直接进行访问的数据结构。

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

哈希函数

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

哈希碰撞 

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

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

 拉链法

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

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

线性探测法

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

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

常见的三种哈希结构

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

set 

集合	底层实现	是否有序	数值是否可以重复	能否更改数值	查询效率	增删效率
std::set	红黑树	有序	否	否	O(log n)	O(log n)
std::multiset	红黑树	有序	是	否	O(logn)	O(logn)
std::unordered_set	哈希表	无序	否	否	O(1)	O(1)

map 

映射	底层实现	是否有序	数值是否可以重复	能否更改数值	查询效率	增删效率
std::map	红黑树	key有序	key不可重复	key不可修改	O(logn)	O(logn)
std::multimap	红黑树	key有序	key可重复	key不可修改	O(log n)	O(log n)
std::unordered_map	哈希表	key无序	key不可重复	key不可修改	O(1)	O(1)

 总结

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

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

 242.有效的字母异位词

 labuladong:

class Solution {
public:
    vector<int> encode(string s){
        vector<int> count(26,0);
         for(char c:s){
                int delta=c-'a';
                count[delta]++;
        }
        return count;
    }
    bool isAnagram(string s, string t) {
        //使用encode函数计算两个字符串中各字符出现的次数
        vector<int> count1=encode(s);
        vector<int> count2=encode(t);
        //判断两个字符串中所有字符出现的数量是否相同
        for(int i=0;i<count1.size();i++){
           if(count1[i]!=count2[i]){
               return false;
           }
        }
        return true;
    }
};

补充：改了一下labuladong的gpt由Java生成的c++代码，将int[ ]方法替换成vector<int>,new int[]也变成count(26,0),java的tCharArray()也不需要了,length换成size()

Carl:

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 i=0;i<t.size();i++){
           record[t[i]-'a']--;
       }
       for(int i=0;i<26;i++){
           if(record[i]!=0){
               return false;
           }
       }
       return true;
    }
};

 349. 两个数组的交集 

 set:

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

 数组：

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result_set;//存放结果，之所以用set是为了给结果集去重
        int hash[1005]={0};//默认数值为0
        for(int num:nums1){
            hash[num]=1;
        }
        for(int num: nums2){//nums2出现的话，result记录
            if(hash[num]==1){
                result_set.insert(num);
            }
        }
        return vector<int>(result_set.begin(),result_set.end());
    }
};

 202. 快乐数

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;
            }
            // 如果这个sum曾经出现过，说明已经陷入了无限循环了，立刻return false
            if(set.find(sum)!=set.end()){
                return false;
            }else {
                set.insert(sum);
            }
            n=sum;
        }
    }
};

1.两数之和

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        std::unordered_map <int,int>map;
        for(int i=0;i<nums.size();i++){
            //遍历当前元素，并在map中寻找是否有匹配的key
            auto iter =map.find(target-nums[i]);
            if(iter !=map.end()){
                return {iter->second,i};
            }
            //如果没找到匹配对，就把访问过的元素和下标加入到map中
            map.insert(pair<int,int>(nums[i],i));
        }
        return {};
    }
};

 补充一下：

unordered_map<int, int> Hashmap;
for (auto p : Hashmap) {
	int front = p.first;   //key
    int end = p.second;   //value
}