算法Day5-CSDN博客

本文链接：https://blog.csdn.net/qq_42189893/article/details/129133553

一、哈希表理论基础

哈希表是什么

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

其实直白来讲数组就是一张哈希表。
哈希表中关键码就是数组的索引下标，然后通过下标直接访问数组中的元素，如下图所示：
Alt
哈希表能解决什么问题呢
一般哈希表都是用来快速判断一个元素是否出现集合里。

哈希函数

例如要查询一个名字是否在这所学校里。我们只需要初始化把这所学校里学生的名字都存在哈希表里，在查询的时候通过索引直接就可以知道这位同学在不在这所学校里了。
将学生姓名映射到哈希表上就涉及到了hash function，也就是哈希函数。把学生的姓名直接映射为哈希表上的索引，然后就可以通过查询索引下标快速知道这位同学是否在这所学校里了。
如下图所示，通过hashCode把名字转化为数值，一般hashcode是通过特定编码方式，可以将其他数据格式转化为不同的数值，这样就把学生名字映射为哈希表上的索引数字了。

常见的三种哈希结构

1. 数组
2. set（集合）
3. map（映射）

set

c++中提供了三种数据结构，如下表所示：

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

std::unordered_set底层实现为哈希表，std::set 和std::multiset 的底层实现是红黑树，红黑树是一种平衡二叉搜索树，所以key值是有序的，但key不可以修改，改动key值会导致整棵树的错乱，所以只能删除和增加。
当我们要使用集合来解决哈希问题的时候，优先使用unordered_set，因为它的查询和增删效率是最优的，如果需要集合是有序的，那么就用set，如果要求不仅有序还要有重复数据的话，那么就用multiset。

特点

Set 对象是一个类数组对象，它长得就很像数组。
Set 对象存储的值是不重复的，所以我们通常使用它来实现数组去重。
Set 对象存储的数据不是键值对的形式，而且它可以存储任何类型的数据。
需要注意的Set对象存储的不是键值对形式，它只存储了值，没有键，就和数组类似。

map

c++中提供了三种数据结构，如下表所示：

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

std::unordered_map 底层实现为哈希表，std::map 和std::multimap 的底层实现是红黑树。同理，std::map 和std::multimap 的key也是有序的。
在map 是一个key value 的数据结构，map中，对key是有限制，对value没有限制的，因为key的存储方式使用红黑树实现的。

特点

Map 对象这种数据结构和和对象类型，都已键值对的形式存储数据，即 key-vlue 形式。
Map 对象存储的数据是有序的，而我们平常使用的对象是无序的，所以通常当我们需要使用对象形式（键值对）存储数据且需要有序时，采用 Map 对象进行存储。
Map 对象的键值可以是任意类型，我们平时使用的对象只能使用字符串作为键。

Map和Set区别

如果我们学会了它们两者如何使用，或多或少都知道它们的区别在哪里，我们这里为大家总结一下它们的区别要点：

Map和Set查找速度都非常快，时间复杂度为O(1)，而数组查找的时间复杂度为O(n)。
Map对象初始化的值为一个二维数组，Set对象初始化的值为一维数组。
Map对象和Set对象都不允许键重复（可以将Set对象的键想象成值）。
Map对象的键是不能改的，但是值能改，Set对象只能通过迭代器来更改值。

二、有效的字母异位词

题目链接

Leetcode242
题目：
给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。
输入: s = “anagram”, t = “nagaram” 输出: true
输入: s = “rat”, t = “car” 输出: false

题目思路

暴力的解法，两层for循环，同时还要记录字符是否重复出现，很明显时间复杂度是 O(n^2)。
数组其实就是一个简单哈希表，而且这道题目中字符串只有小写字符，那么就可以定义一个数组，来记录字符串s里字符出现的次数。
需要定义一个多大的数组呢，定一个数组叫做record记录字符串s中字母出现次数，大小为26 就可以了，初始化为0，因为字符a到字符z的ASCII也是26个连续的数值。因为字符a到字符z的ASCII是26个连续的数值，所以字符a映射为下标0，相应的字符z映射为下标25。

代码

哈希表（数组）

class Solution {
public:
    bool isAnagram(string s, string t) {
        int hash[26] = {0};
        for(int i=0;i<s.size();i++)
            hash[s[i]-'a']++;   //因为仅包含小写字母，ASCII码连续
        for(int i=0;i<t.size();i++)
            hash[t[i]-'a']--;
        for(int i=0;i<26;i++){
            if(hash[i] != 0)    //当不为0时，说明对应字母出现次数不相同
                return false;
        }
        return true;
    }
};

时间复杂度：O(⁡n)
空间复杂度：O(1)，空间上定义一个常量大小的辅助数组。

三、两个数组的交集

题目链接

Leetcode349
题目：
给定两个数组 nums1 和 nums2 ，返回它们的交集。输出结果中的每个元素一定是唯一的。我们可以不考虑输出结果的顺序。
输入：nums1 = [1,2,2,1], nums2 = [2,2]输出：[2]

题目思路

同Leetcode242可使用数组进行，但如果这道题目没有限制数值的大小，就无法使用数组来做哈希表了。
当没限制数值大小或哈希值比较少、特别分散、跨度非常大（使用数组就造成空间的极大浪费）时，就要使用另一种结构体set。
std::set和std::multiset底层实现都是红黑树，std::unordered_set的底层实现是哈希表，使用unordered_set 读写效率是最高的，并不需要对数据进行排序，而且还不要让数据重复，所以选择unordered_set。

代码

哈希表（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 i = 0; i< nums2.size(); i++) {
            // 发现nums2的元素 在nums_set里又出现过
            if (nums_set.find(nums2[i]) != nums_set.end()) {
                result_set.insert(nums2[i]);
            }
        }
        return vector<int>(result_set.begin(), result_set.end());
    }
};

时间复杂度：O(m+n)
空间复杂度：O(m+n）

四、快乐数

题目链接

Leetcode202
题目：
编写一个算法来判断一个数 n 是不是快乐数。
「快乐数」定义为：
对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。然后重复这个过程直到这个数变为 1，也可能是无限循环但始终变不到 1。如果这个过程结果为 1，那么这个数就是快乐数。如果 n 是快乐数就返回 true ；不是，则返回 false 。
输入：n = 19 输出：true
解释：
1² + 9² = 82
8² + 2² = 68
6² + 8² = 100
1² + 0² + 0² = 1

题目思路

题目中说了会无限循环，那么也就是说求和的过程中，sum会重复出现，这对解题很重要！
当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法了。
判断sum是否重复出现就可以使用unordered_set。
在这里插入图片描述

代码

哈希表（set）

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;
        }
    }
};

在这里插入图片描述

五、两数之和

题目链接

Leetcode1
题目：
给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出和为目标值 target 的那两个整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
输入：nums = [2,7,11,15], target = 9 输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

题目思路

什么时候使用哈希法
当我们需要查询一个元素是否出现过，或者一个元素是否在集合里的时候，就要第一时间想到哈希法。
本题就需要一个集合来存放我们遍历过的元素，然后在遍历数组的时候去询问这个集合，某元素是否遍历过，也就是是否出现在这个集合。
因为我们不仅要知道元素有没有遍历过，还有知道这个元素对应的下标，需要使用 key value结构来存放，key来存元素，value来存下标，那么使用map正合适。

使用数组和set来做哈希法的局限

数组的大小是受限制的，而且如果元素很少，而哈希值太大会造成内存空间的浪费。
set是一个集合，里面放的元素只能是一个key，而两数之和这道题目，不仅要判断y是否存在而且还要记录y的下标位置，因为要返回x 和 y的下标。所以set 也不能用。

代码

哈希表（map）

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 {};
    }
};

时间复杂度：O(n)
空间复杂度：O(n）