代码随想录_Day6_哈希表_1

哈希：实现一种键(key)值(value)匹配。

哈希优势：弥补数组下标索引无意义和链表查找慢（O(n)复杂度）的不足，实现O(1)复杂度的查找。

242. 有效的字母异位词 - 力扣（LeetCode）

暴力解法：

class Solution {
public:
    bool isAnagram(string s, string t) {
        vector<int> t_count(26, 0);
        vector<int> s_count(26, 0);
        for(int i=0;i<size(s);i++){
            s_count[s[i]-'a']++;
        }
       
        for( int j=0;j<size(t);j++){
            t_count[t[j]-'a']++;
        }
        
        for(int i=0;i<26;i++){
            if(s_count[i]!=t_count[i])
            {
                return false;
            }
        
        }
        return true;
    }
};

哈希表

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

};

核心思想：引入哈希函数，将任意长度的“键”映射到一个固定范围的数组下标上，从而将查找问题转化为数组的随机访问问题。

349. 两个数组的交集 - 力扣（LeetCode）

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
         vector<int>result;
         for(int i=0;i<size(nums1);i++){
            for(int j=0;j<size(nums2);j++)
            if(nums2[j]==nums1[i]){
                result.push_back(nums1[i]);//可以运行但是解答错误
            }
         }  
    return result;
    }
};
/*nums1={1,2,2},nums2={2,2}
输出为：2，2，2，2
正确输出为：2
尝试在内层循环加上break;
输出会变为：2,2
问题的关键在于输出的元素要是唯一的；所以要在输出之前增加一个去重处理*/
 for(int i = 0; i < result.size(); i++) {
            for(int j = i + 1; j < result.size(); j++) {
                if(result[j] == result[i]) {
                    result.erase(result.begin() + j);  // 不能直接使用delete result[j],其一，因为vector使用erase进行删除；其二，vector 的 erase() 方法的参数是迭代器（iterator），不是下标索引，故使用erase(result.begin()+j）；
                    j--;  // 调整索引
                }
            }
        }

需要一个可以自动调整重复元素的数据类型，set登场！

set

一种关联容器，可以自动排序和去重。

在C++中，unordered_set 和 unordered_map都是哈希结构，它们提供了O(1)时间复杂度的查找、插入和删除操作。

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
         unordered_set<int>result;
         for(int i=0;i<size(nums1);i++){
            for(int j=0;j<size(nums2);j++)
            if(nums2[j]==nums1[i]){
                result.insert(nums1[i]);
            }
         }  
    return vector<int>(result.begin(),result.end());//set同样使用迭代器，需要迭代器的容器还包括vector、map、list等。

1. 两数之和 - 力扣（LeetCode）

暴力解法

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

时间复杂度：O（n*n)；

哈希表法：

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int> Map;  // key: 数字, value: 索引
        for(int i = 0; i < nums.size(); i++) {
            auto iter = Map.find(target-nums[i]);
            if(iter!= Map.end()){
                return {iter->second,i};//iter是一个指向pair<int,int>的迭代器。iter->second是补数的索引(value)，iter->first是补数（key)。
            }

　　　　　　　　Map[nums[i]]=i;//（这句真是不理解啊）   在hash表中建立数字-索引的对应关系

　　　　　　　　//Map.insert(pair<int,int>(nums[i],i));

        }
        return {};  // 无解
    }
};

时间复杂度：O（n)；

快乐数：

class Solution {
public:
    int get_Sum(int n) {
        int sum = 0;
        int dignit;
        while (n) {//当n不为0时循环
            dignit = n % 10;
            sum += (dignit) * (dignit);
            n = n / 10;
        }
        return sum;
    }
    bool isHappy(int n) {
        unordered_set<int> set;
        while (1) {
            int sum;
            sum = get_Sum(n);
            if (sum == 1) {
                return true;
            }

            if (set.find(sum) != set.end()) {//在set容器中找到了sum;set.end() 返回一个指向集合末尾的迭代器，实际指向最后一个元素的下一个位置。
                return false;
            } else {
                set.insert(sum);
            }

            n = sum;
        }
    }
};