代码随想录算法训练营第6天 |第三章哈希表part01-CSDN博客

本文链接：https://blog.csdn.net/qq_43750923/article/details/134786304

学习目标：

242. 有效的字母异位词
349. 两个数组的交集
202. 快乐数
1. 两数之和

学习内容：

常见的三种哈希结构

数组：哈希表较小的时候使用
set（集合）：哈希表大的时候使用
map（映射）：有特定value的时候使用

242. 有效的字母异位词

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。

注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。

//方法1
class Solution {
public:
    bool isAnagram(string s, string t) 
    {
        vector<int> hash(26,0); //定义一个数组来记录每个字符出现的次数，因为这题目中假设所有字符都是小写字母，所以一共留26个位置就可以。
        //另一种定义数组的写法
        // int record[26] = {0};
        for(int i = 0; i<s.size();i++)
        {
        	//可以称之为【相对路径法】，不需要记住a-z的ASCII码，只需要找到相对的位置就可以了。
            hash[s[i]-'a']++;
        }
        for(int i=0;i<t.size();i++)
        {
        	//反过来遇到相同的字符，就减去一个。
            hash[t[i]-'a']--;
        }
        for(int i=0;i<26;i++)
        {
            if(hash[i]!=0){
                return false;
            }
        }
        return true;

    }
};

错误以及注意事项

错误1：vector hash(26,0);最开始写成了vector hash(25,0);vector：这部分指定了 vector 的类型，即包含整数 (int) 元素的向量。(26, 0)：这是一个初始化参数。其中的 26 指定了向量的大小，即向量中包含的元素个数为 26。而 , 0 则表示这 25 个元素的初始值都设置为 0。

349. 两个数组的交集

//方法一,使用数组。
class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        // 用一个数组来保存这两个数组的交集
        // vector<int> result(1000,0);
        // 使用 unordered_set 保存交集，确保唯一性
        unordered_set<int> result;
        vector<int> a(1000,0);
        vector<int> b(1000,0);
        for(int i = 0; i < nums1.size();i++)
        {
            a[nums1[i]]++;
        }
        for(int i = 0; i < nums2.size();i++)
        {
            b[nums2[i]]++;
        }
        for(int i = 0; i<1000;i++)
        {
            int k = 0;
            if(a[i]!=0 && b[i]!=0){
                // result[k++] = i;
                result.insert(i);
            }
        }
        return vector<int>(result.begin(), result.end());
    }
};

错误以及注意事项

但是要注意，使用数组来做哈希的题目，是因为题目都限制了数值的大小。而且如果哈希值比较少、特别分散、跨度非常大，使用数组就造成空间的极大浪费。这时候我们考虑用set来做题。

set的几种数据结构

set
unorderedset
multiset

//方法2
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());
    }
};

错误以及注意事项

nums_set.find(num) 返回一个迭代器，指向 nums_set 中包含元素 num 的位置，如果 num 不存在于 nums_set 中，返回的迭代器等于 nums_set.end()。因此，nums_set.find(num) != nums_set.end() 的条件判断就是在检查元素 num 是否存在于 nums_set 中。如果条件成立，表示 num 在 nums_set 中找到，说明 num 同时存在于 nums1 和 nums2 中，因此将其插入到结果集 result_set 中。（看上面unordered_set的超链接！！）

202. 快乐数

比较难思考到的地方是，sum存入set，每一次循环的时候检查sum是否出现过，如果出现过，那就代表会进入循环，无法变成快乐数，如果没有考虑到这一块的话会造成程序无限循环

class Solution
{
public:
    int getSum(int n)
    {
        int sum = 0;
        while (n)
        {
            sum = sum + (n % 10) * (n % 10);
            n = n / 10;
        }
        return sum;
    }

    bool isHappy(int n)
    {
        unordered_set<int> set; // 用来查看这次出现的数字是否出现过
        while (1)
        {
            int sum = getSum(n);
            if (sum == 1)
            {
                return true;
            }
            if (set.find(sum)!=set.end()){
                return false;//说明这个sum以前出现过了，会陷入循环
            }
            else{
                set.insert(sum);
            }
            n=sum;
        }
    }
};

1. 两数之和

再说一遍，有人相爱，有人夜里开车看海，有人leetcode第一题都做不出来。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int> valToIndex;
        for(int i=0; i<nums.size();  i++)
        {
            int need = target-nums[i];
            //找valToIndex中有没有need
            if(valToIndex.count(need)){
                return vector<int>{valToIndex[need], i};
            }
            //建立valToIndexmap// 如果没找到匹配对，就把访问过的元素和下标加入到map中
            valToIndex[nums[i]] = i;
        }
        return vector<int>{};
    }
};