哈希表：有效字母异位词两个数组交集快乐数两数之和

暁_

已于 2023-11-13 22:06:40 修改

阅读量873

点赞数

文章标签：散列表数据结构

于 2023-11-13 22:02:57 首次发布

本文链接：https://blog.csdn.net/m0_59425585/article/details/134379581

版权

哈希表理论基础

哈希表(散列表) ：根据关键码的值而直接进行访问的数据结构。
适用情景：遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法。(牺牲空间换取时间)
哈希函数：通过哈希函数，将元素映射为哈希表上的索引，然后就可以通过索引下标快速查询。具体学习参考链接
哈希冲突(哈希碰撞)：多个元素映射到同一个下标
- 解决方法：
- 1. 拉链法：将发生冲突的函数存储在链表或其他数据结构中，哈希表的节点成为该链表的头结点。
- 2. 线性探测法：一旦发生了冲突，就去寻找下一个空的哈希地址。这个方法依赖哈希表中空位来解决冲突，所以一定要保证tableSize大于dataSize。
常见哈希结构
- 数组：适用于数值小，数值不那么分散
- set（集合）：适用于哈希值比较少、特别分散、跨度非常大
- map（映射）

有效字母异位词

题目：Leetcode242
思路：由于a-z对应的ASCII码是连续的，所以可以把a对应到数组下标为0的位置，z对应到下标为25的位置。用一个数组统计第一个字符串中每个字母出现的频率，在遍历第二个字符串时，做对应的减法。也就是说假设第一个字符串中字母a出现了3次，映射到数组中元素值为3，如果第二个字符串是它的有效字母异位词，那么遍历完第二个字符串，对应元素值会减到为0。如果最终该数组所有元素都为0，则它们是有效字母异位词。
时间复杂度：O(n)

class Solution {
public:
    bool isAnagram(string s, string t) {
        int hash[26] = {0};
        for(int i = 0; i < s.size(); i++) {
            //将字符串s映射到hash的索引中
            //若s[i]=='a'， 则s[i]-'a'=0，即映射到hash中索引为0的位置，对应位置元素值+1
            hash[ s[i] - 'a']++;
        }
        for(int i = 0; i < t.size(); i++) {
            hash[ t[i] - 'a']--;
        }
        for(int i = 0; i < 26; i++) {
            //若hash中存在值不为0的元素，说明不是有效字母异位词
            if(hash[i] != 0) {
                return false;
            }
        }
        //hash中元素全为0，则这两个字符串为有效异位词
        return true;
    }
};

两个数组交集

题目：Leetcode349
思路：将nums1中元素映射到哈希表中进行存储，然后在哈希表中查找nums2的元素，找到了就放进结果数组result中。要求结果去重且不用排序，可以使用unordered_set，映射和取值效率最高。
时间复杂度: O(mn)
find函数：STL的find函数的输入查找范围参数都是指针或是迭代器，返回的也是指针或是迭代器，常常使用返回值是否等于end来判断是否查找成功。

解法一：set

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result;//存放结果，使用unordered_set可去重
        unordered_set<int> hash(nums1.begin(), nums1.end());//将nums1转换为unordered_set
        for(int num : nums2) {
            //遍历nums2，如果在hash中找到nums2中的元素，则将该元素放入结果集合中
            if(hash.find(num) != hash.end()) {
                result.insert(num);
            }
        }
        return vector<int>(result.begin(), result.end());
    }
};

解法二：数组

数组优点：
- 不需要hash运算
- 不需要额外开辟新的空间

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result;//存放结果，使用unordered_set可去重
        int hash[1005] = {0};//记录nums1中出现的所有元素
        for(int i = 0; i < nums1.size(); i++) {
            //nums1[i]的值作为hash的下标，对应hash值赋值为1
            hash[nums1[i]] = 1;
        }
        for(int i = 0; i < nums2.size(); i++) {
            if(hash[nums2[i]] == 1) { //说明在nums1中出现过
                result.insert(nums2[i]);
            }
        }
        return vector<int>(result.begin(), result.end());
    }
};

快乐数

题目：Leetcode202
思路：会 无限循环，那么也就是说求和的过程中，sum会重复出现，遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法。
时间复杂度: O(logn)

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;
            }
            //如果set中已存在相等的sum，说明即将进入无限循环，这个数不是快乐数
            if(set.find(sum) != set.end()) {
                return false;
            }
            else {
                set.insert(sum);
            }
            //更新n，进行下一次计算
            n = sum;
        }
    }
};

两数之和

题目：Leetcode1
思路：
- 为什么使用哈希法？
  - 本题中使用一个集合存放遍历过的元素，然后在遍历数组时询问集合，某个元素是否遍历过，因此使用哈希法。
- 为什么使用unordered_map？
  - 数组大小受限，元素少时造成空间浪费。
  - set的元素只有一个key，而这道题需要记录元素的值和下标。
  - map是一种<key,value>的存储结构，可以用key保存数值，用value再保存数值所在的下标。这道题目中并不需要key有序，选择std::unordered_map 效率更高.
- map是用来做什么的？
  - 存放我们访问过的元素。
- map中key存放什么？value存放什么？
  - key：数据元素，value：数组元素对应的下标
- 补充：为什么key存放的是元素，而不是下标？
  - map能在最快的时间内，查找这个key是否在map中出现过，本题要查找的是元素是否遍历过，因此key存放的是元素。
时间复杂度: O(n)

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int,int> map;//存放遍历过的元素
        for(int i = 0; i < nums.size(); i++) {
            //查找与nums[i]匹配的元素s是否已经遍历过
            int s = target - nums[i];
            auto iter = map.find(s);
            if(iter != map.end()) { //s已经遍历过
                return {iter->second, i}; //返回两个下标
            }
            //s没有遍历过，将元素nums[i]及其下标存放进map中
            map.insert(pair<int, int>(nums[i], i));
        }
        return {};
    }
};