代码随想录Day6—哈希表part01

1. 哈希表理论基础

哈希表通过建立 [键 key] 与 [值 value] 之间的映射，实现高效的元素查询。具体而言，向哈希表输入一个key，可以在 O(1) 时间内获取对应的value。

哈希表解决问题：用来快速判断一个元素是否出现在集合里。其增删查改的施加复杂度都是 O(1)，相较于数组和链表全面胜出。

2. 242有效的字母异位词

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

示例1：输入: s = "anagram"，t = "nagaram" 输出：true

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

说明：假设字符串只包含小写字母。

思路：通过哈希表来判断

1. 创建一个数组record[]，元素全置为0，来记录是否字符出现的次数都相同。下标0—25对应 字母a~z(哈希表的思想)

2. for (遍历第一个数组s): s 的每个字符，record[] 都对应++，即record[0] = 1, record[1] = 1...... 其中0为’a'-'a',1为‘b'-'a', 以此类推，表示 a 出现1次，b 出现1次。

3. for (遍历第二个数组t): t 的每个字符，record[] 都对应--，在第一个数组频率统计的基础上，减去

4. for (遍历 record数组)：若全为0，则是；否则，则不是。

代码如下：

#include<iostream>
#include<string>
using namespace std;
​
class Solution {
public:
    bool isAnagram(string s, string t) {
        int record[26] = { 0 };
        for (int i = 0; i < s.size(); i++) { //遍历第一个字符串元素
            record[s[i] - 'a']++; // 统计字符出现的频率
        }
        for (int i = 0; i < t.size(); i++) { //遍历第二个字符串元素
            record[t[i] - 'a']--; // 减去第二个字符串中字符出现的频率
        }
        for (int i = 0; i < 26; i++) {
            if (record[i] != 0) {
                return false;
            }
        }
        return true;
    }
};
​
int main(void) {
    Solution solu;
    string s = "anagram";
    string t = "nagaram";
    cout << solu.isAnagram(s, t) << endl;
​
    system("pause");
    return 0;
}

3. 349两个数组的交集

题目：给定两个数组，编写一个函数来计算它们的交集

思路：

1. 用unordered_set 来存储第一个数组元素

2. 用第二个数组去查询，如果又出现过，则返回值。

代码如下：（利用set)

#include<iostream>
#include<vector>
#include<unordered_set>
using namespace std;
​
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()); //将nums1放进set中
        for (int num: nums2) {
            // 发现nums2的元素，在nums_set里又出现过
            if (nums_set.find(num) != nums_set.end()) { //find()函数返回的是一个迭代器，如果没找到，返回的是end()
                result_set.insert(num); // 将这个元素放进结果set中
            }
        }
        return vector<int>(result_set.begin(), result_set.end()); //意思是将set中的元素放进vector中
    }
};
​
int main(void) {
    Solution solu;
    vector<int> nums1 = { 2,2,9,4,6 };
    vector<int> nums2 = { 1,2,2,1 };
    vector<int> result = solu.intersection(nums1, nums2);
    for (int i = 0; i < result.size(); i++) {
        cout << result[i] << endl;
    }
​
    system("pause");
​
    return 0;
}
利用数组

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result_set;
        int hash[1005] = { 0 };
        for (int num : nums1) {
            hash[num] = 1;
        }
        for (int num : nums2) {
            if (hash[num] == 1) {
                result_set.insert(num);
            }
        }
        return vector<int>(result_set.begin(), result_set.end());
    }
};

4. 202快乐数

题目：编写一个函数判断一个数 n 是不是快乐数

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

如果 n 是快乐数就返回 True；不是，则返回 False。

示例：

输入：19 输出：true 解释： 1^2 + 9^2 = 82 8^2 + 2^2 = 68 6^2 + 8^2 = 100 1^2 + 0^2 + 0^2 = 1

思路：该问题说求和过程，sum会不会出现1，即“1” 会不会出现。采用哈希法

1. 获取一个数的各个位上的数字 求和

2. 写一个循环判断sum是否取到1，如果取到则返回true。如果一直循环，则返回false。

注意：判断sum是否重复出现就可以使用unordered_set。

代码如下：

#include<iostream>
#include<unordered_set>
using namespace std;
​
class Solution {
public:
​
    int getSum(int num) {
        int sum = 0;
        while (num) {
            int x = num % 10; //获取个位数；
            sum += x * x; 
            num /= 10; //获取十位数
        }
        return sum;
    }
​
    bool isHappy(int num) {
        unordered_set<int> set;
        while (1) { // 判断sum是否为1
            int sum = getSum(num);
            if (sum == 1) {
                return true;
            }
            if (set.find(sum) != set.end()) { //没找到，返回end()， 不等于end()说明找到了
                return false;
            }
            else {
                set.insert(sum);//将sum放进set中
            }
            num = sum; //更新num
        }
    }
};
​
int main(void) {
    Solution s;
    cout << s.isHappy(19) << endl;
    return 0;
}

5. 1两数之和

题目：给定一个整数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那两个整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

示例：

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9

所以返回 [0, 1]

思路：

1. 如何想到采用哈希表？

这道题遍历一个元素a时，需要判断另一个元素target-a 是否出现过。—> 采用哈希表的方法

1. 采用哪种哈希表结构？

本题需要查询数值和下标，采用map结构，想要查找元素是否出现过，就把元素当作key

解题过程：

1. 创建一个map

2. for (遍历 nums):

一个个存到map中，同时查找另一个数是否遍历过，若存在则返回下标

1. 若不存在，则返空

代码如下：

#include<iostream>
#include<vector>
#include<unordered_map>
using namespace std;
​
class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        //1. 定义一个map
        std::unordered_map<int, int> map; //map用来存放遍历过的元素
        for (int i = 0; i < nums.size(); i++) {
            //2. 遍历当前元素，并在map中寻找是否又匹配的key
            int s = target - nums[i]; //目标值减去当前一个元素，求另一个元素s
            auto iter = map.find(s); // 在map寻找有无s
            if (iter != map.end()) { // 如果找到了
                return { iter->second, i };
            }
            //如果没找到，就把访问过的元素和下标加入到map中
            map.insert(pair<int, int>(nums[i], i));
        }
        return {};
    }
};
​
int main(void) {
    Solution solu;
    vector<int> nums = { 2,7,11,15 };
    vector<int> result = solu.twoSum(nums, 9);
    for (int i = 0; i < result.size(); i++) {
        cout << result[i] << endl;
    }
​
    system("pause");
​
    return 0;
}