关于《哈希表》的基础解析（上）

目录

1.哈希表的基础理论

 哈希表

 哈希函数

哈希碰撞

2.有效的字母异位词

3.两个数组的交集

4.快乐数

一个 “快乐数” 定义为：对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和，然后重复这个过程直到这个数变为 1，也可能是无限循环但始终变不到 1。 如果可以变为 1，那么这个数就是快乐数。

---

1.哈希表的基础理论

 哈希表

什么是哈希表呢？我们来看一下官方解释： 哈希表（Hash table又称散列表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做哈希表。

简而言之，数组就是一张哈希表。

哈希表的关键码就是数组的索引下标，然后通过直接访问数组中的元素，如下图：

我们发现，哈希表和数组的形式是一样的。

通过哈希表，我们可以快速地判断一个元素是否出现在集合里。 

 哈希函数

哈希函数指将哈希表中元素的关键键值映射为元素存储位置的函数。

又是十分专业但抽象的官方解释，简而言之，通过哈希函数我们可以把目标值映射在哈希表上的索引数字。

但是，如上表所示，哈希表的一个索引数字对应的不只有一个元素，这时，“来不及哀悼哈希函数，哈希碰撞登场！”

哈希碰撞

当两个元素映射到了同一索引下标时，这种情况叫做哈希碰撞。

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

拉链法：

拉出一个动态链表代替静态顺序存储结构，可以避免哈希函数的冲突，不过缺点就是链表的设计过于麻烦，增加了编程复杂度。此法可以完全避免哈希函数的冲突。

基本结构如上表所示。

线性探测法：

使用线性探测法，要保证tableSize大于dataSize，即哈希表大小大于数组大小。当出现哈希碰撞时，我们可以通过哈希表中的空位来解决冲突。

如：当元素1，2都映射在了索引值为1的位置，那么：

当然，这只是介绍了简单的处理方法，深层的东西需要各位独自研究。

---

作者的能力有限，哈希表的基本理论就介绍到这里。哈希法通过牺牲空间换取了时间，用于快速判断一个元素是否出现在集合里。 

2.有效的字母异位词

 对于“字母异位词”，简单理解就是：两字符串的长度相同，字母相同，但顺序不同。

对于字母异位词的解法很容易想到在关于《长度最小的子数组》的基础解析中的思路，建立两个表格，分别统计两个字符串中的元素种类与出现个数，随后进行比较。

然而代码过于麻烦，今天我们采用更简洁的代码并通过例题对哈希表进行理解。

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

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

示例 1:

输入: s = "anagram", t = "nagaram"
输出: true

示例 2:

输入: s = "rat", t = "car"
输出: false

思路：数组作为一张简单的哈希表，我们建立一个新的数组，记录字符串s，t中字符出现的次数，而字符作为索引下标映射在哈希表中。

具体操作为定义数组record，大小为26，初始化为0，因为字符‘a’到字符‘z’在ASCII码表上是26个连续的数值。那么数组下标中，‘a'对应的是0，’z‘对应的是25。

在遍历字符串s时，只需要将s[i]-'a'（其差值就代表了对应的字符）对应的元素+1即可，这样某个字符出现的次数就被统计出来了，之后遍历字符串t时，将t[i]-'a'对应的元素-1。

最后，如果record中的元素都为0，则说明s,t的字符出现的种类与次数一样，即为字母异位词，return true。如果record中有元素不为0，则说明s或t有某个字符串多了或者少了字符，return false。

代码如下：

bool isAnagram(char* s, char* t) {
      int record[26] = {0};
      int lens=strlen(s);
      int lent=strlen(t);
        for (int i = 0; i < lens; i++) {
            record[s[i] - 'a']++;
        }
        for (int i = 0; i < lent; i++) {
            record[t[i] - 'a']--;
        }
        for (int i = 0; i < 26; i++) {
            if (record[i] != 0) {
                return false;
            }
        }
        return true;
}

例2：给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。

如果可以，返回 true ；否则返回 false 。

magazine 中的每个字符只能在 ransomNote 中使用一次。

示例 1：

输入：ransomNote = "a", magazine = "b"
输出：false

示例 2：

输入：ransomNote = "aa", magazine = "ab"
输出：false

示例 3：

输入：ransomNote = "aa", magazine = "aab"
输出：true

 思路：基本思路与上一题一样，只是多出一个判断条件，用于判断元素出现的次数是否符合。

具体代码如下：

bool canConstruct(char* ransomNote, char* magazine) {
    int record[26]={0};
    int lenr=strlen(ransomNote);
    int lenm=strlen(magazine);
    if(lenr>lenm){
        return false;
    }
    for(int i=0;i<lenm;i++){
        record[magazine[i]-'a']++;
    }
    for(int j=0;j<lenr;j++){
        record[ransomNote[j]-'a']--;
        if(record[ransomNote[j]-'a']<0){ //该判断条件表示magazine中某个字符出现的次数小于ransomNote中的
            return false;
        }
    }
    return true;
}

例3：给你一个字符串数组，请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。

字母异位词 是由重新排列源单词的所有字母得到的一个新单词。

示例 1:

输入: strs = ["eat", "tea", "tan", "ate", "nat", "bat"]
输出: [["bat"],["nat","tan"],["ate","eat","tea"]]

示例 2:

输入: strs = [""]
输出: [[""]]

示例 3:

输入: strs = ["a"]
输出: [["a"]]

 思路：在查找字母异位词的同时建立新数组，将查找到的同类字母异位词定在新数组的元素中。

class Solution {
public:
    vector<vector<string>> groupAnagrams(vector<string>& strs) {
        map<string,int> myhash;
        vector<vector<string>> ans;
        int len=strs.size();
        int cnt=0;
        for(int i=0;i<len;i++){
            string tmp=strs[i];
            sort(strs[i].begin(),strs[i].end());
            if(myhash.find(strs[i])==myhash.end()){
                ans.push_back(vector<string>());
                ans.back().push_back(tmp);
                myhash[strs[i]]=cnt;
                cnt++;
            }else{
                int index=myhash[strs[i]];
                ans[index].push_back(tmp);
            }

        }
        return ans;
    }
};

例4：给定两个字符串 s 和 p，找到 s 中所有 p 的 异位词 的子串，返回这些子串的起始索引。不考虑答案输出的顺序。

异位词 指由相同字母重排列形成的字符串（包括相同的字符串）。

示例 1:

输入: s = "cbaebabacd", p = "abc"
输出: [0,6]
解释:
起始索引等于 0 的子串是 "cba", 它是 "abc" 的异位词。
起始索引等于 6 的子串是 "bac", 它是 "abc" 的异位词。

 示例 2:

输入: s = "abab", p = "ab"
输出: [0,1,2]
解释:
起始索引等于 0 的子串是 "ab", 它是 "ab" 的异位词。
起始索引等于 1 的子串是 "ba", 它是 "ab" 的异位词。
起始索引等于 2 的子串是 "ab", 它是 "ab" 的异位词。

话不多说，我们直接看代码：

class Solution {
public:
    vector<int> findAnagrams(string s, string p) {
        int n = s.size(), m = p.size();
        if (n < m) return {};
        vector<int> maps(26);
        vector<int> mapp(26);
        for(auto& c : p) {
            mapp[c - 'a']++;
        }
        vector<int> ans;
        for(int i = 0;i < n;i++) {
            maps[s[i] - 'a']++;
            if(i >= m - 1) {  
                if (mapp == maps) ans.push_back(i - m + 1);
                maps[s[i - m + 1] - 'a']--;
            }
        }
        return ans;
    }
};

3.两个数组的交集

在求解此类题目之前，我们要知道，用数组来做哈希的题目，是因为题目上都限制了数值的大小。而这种题目在没有限制数值大小的情况下，就无法用数组进行操作了。

此时引入哈希另一种数据结构：set ，关于set，C++ 给提供了如下三种可用的数据结构：

• std::set
• std::multiset
• std::unordered_set

std::set和std::multiset底层实现都是红黑树，std::unordered_set的底层实现是哈希表， 使用unordered_set 读写效率是最高的，并不需要对数据进行排序，而且还不要让数据重复，所以选择unordered_set。

另有关于哈希结构，大家可自行研究。

例：给定两个数组 nums1 和 nums2 ，返回 它们的交集 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。

示例 1：

输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2]

示例 2：

输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出：[9,4]
解释：[4,9] 也是可通过的

本题注意题目的特别说明：输出结果中的每个元素是唯一的，即输出的结果是去重的，同时不考虑输出的顺序。

代码如下：

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
         unordered_set<int> result_set; 
        unordered_set<int> nums_set(nums1.begin(), nums1.end());
        for (int num : nums2) {
            if (nums_set.find(num) != nums_set.end()) {
                result_set.insert(num);
            }
        }
        return vector<int>(result_set.begin(), result_set.end());
    }
};

例：给你两个整数数组 nums1 和 nums2 ，请你以数组形式返回两数组的交集。返回结果中每个元素出现的次数，应与元素在两个数组中都出现的次数一致（如果出现次数不一致，则考虑取较小值）。可以不考虑输出结果的顺序。

示例 1：

输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2,2]

示例 2:

输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出：[4,9]

 思路：本题与上题类似，本次采用C代码，通过排序与双指针的方式输出所需数组。

int cmp(const void* _a, const void* _b) {
    int *a =(int*) _a,*b = (int*)_b;
    return *a == *b ? 0 : *a > *b ? 1 : -1;
}
int* intersect(int* nums1, int nums1Size, int* nums2, int nums2Size, int* returnSize) {
    qsort(nums1, nums1Size, sizeof(int), cmp);
    qsort(nums2, nums2Size, sizeof(int), cmp);
    *returnSize = 0;
    int* intersection = (int*)malloc(sizeof(int) * fmin(nums1Size, nums2Size));
    int index1 = 0, index2 = 0;
    while (index1 < nums1Size && index2 < nums2Size) {
        if (nums1[index1] < nums2[index2]) {
            index1++;
        } else if (nums1[index1] > nums2[index2]) {
            index2++;
        } else {
            intersection[(*returnSize)++] = nums1[index1];
            index1++;
            index2++;
        }
    }
    return intersection;
}

 

4.快乐数

一个 “快乐数” 定义为：对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和，然后重复这个过程直到这个数变为 1，也可能是无限循环但始终变不到 1。 如果可以变为 1，那么这个数就是快乐数。

例：编写一个算法来判断一个数 n 是不是快乐数。

「快乐数」 定义为：

• 对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
• 然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
• 如果这个过程 结果为 1，那么这个数就是快乐数。

如果 n 是 快乐数 就返回 true ；不是，则返回 false 。

示例 1：

输入：n = 19
输出：true
解释：
12 + 92 = 82
82 + 22 = 68
62 + 82 = 100
12 + 02 + 02 = 1

示例 2：

输入：n = 2
输出：false

思路： 快乐数和不快乐数之间，除了最后的平方和不为1外，不快乐数最后的平方和会陷入无限循环中，以sum代表平方和，则sum会重复出现在哈希表中。以此为依据区分快乐数与不快乐数。

代码如下

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;
            }
            if(set.find(sum)!=set.end()){
                return false;
            }
            else{
                set.insert(sum);
            }
            n=sum;
        }
    }
};

---

上述简单介绍了哈希表的基础理论和简单操作，对哈希表有一个基本的了解。

另有下篇将在后续发表。

上述题目均来自力扣 (LeetCode) 全球极客挚爱的技术成长平台​​​​​​

借鉴来源代码随想录 (programmercarl.com)