代码随想录-哈希表|ACM模式

希希雾里

已于 2023-09-30 20:44:49 修改

阅读量321

点赞数 3

分类专栏：代码随想录感想文章标签：哈希算法算法 leetcode 数据结构

于 2023-09-30 19:24:21 首次发布

本文链接：https://blog.csdn.net/weixin_42373086/article/details/133437935

版权

代码随想录感想专栏收录该内容

23 篇文章 0 订阅

订阅专栏

前言：

（1）基本概念

就是用哈希函数构建索引和内容之间的映射。就相当于一个内容就会有相对应的哈希函数值（即索引下标），直接找下标，就能查询是否有相应的内容。

在这个过程中，可能会遇到两个同时映射到一个，这个就是哈希碰撞的现象，应对这个方法常见的有两种，其中一个是拉链法（即采用链表的方式），另一个就是线性探测法。

①拉链法需要选择适当的哈希表的大小----不会因为数组空值而浪费大量内存，另一个不会链表太长而在查找上浪费太多时间。

②线性探测法，一定要保证tablesize大于datasize。依靠哈希表空位来解决碰撞问题。

（2）常见的三种哈希结构

数组、set（集合）以及map（映射）

242.有效字母的异位词

题目描述：

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

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

输入输出描述：

示例 1:

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

示例 2:

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

提示:

1 <= s.length, t.length <= 5 * 104
s 和 t 仅包含小写字母

思路和想法:

这个问题可以分为三个步骤来解决。

步骤一：构建Hash table-数组，之后遍历第一个字符串将里面的元素一一对应到哈希表上记录频次。
步骤二：再遍历第二个字符串，将相应位置--。
步骤三：最终只需判断哈希表内元素是否都为零，就可以判断这两个字符串是否互为有效字母异位词。

#include <bits/stdc++.h>
using namespace std;
bool isAnagram(string s, string t) {
    //将a-z，26个字母到0-25
    //哈希表
    unordered_map<int, int> m;
    for(int i = 0; i < s.size(); i++ ){
        m[s[i]-'a']++;
    }
    for(int i = 0; i < t.size(); i++){
        m[t[i]-'a']--;
    }
    for(int i = 0; i < 26;i++){
        if(m[i] != 0) return false;
    }
    return true;
}
int main() {
    string s,t;
    getline(cin,s);
    getline(cin,t);

    bool result;
    result = isAnagram(s,t);

    if(result == 1){
        cout << "true";
    }else{
        cout << "false";
    }
    return 0;
}
/************
示例1:
anagram
nagaram
示例2:
rat
car
*************/

349. 两个数组的交集

题目描述：

给定两个数组 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] 也是可通过的

提示：

1 <= nums1.length, nums2.length <= 1000
0 <= nums1[i], nums2[i] <= 1000

思路和想法：

可以清晰的知道我们要判断元素在集合中是否出现过。这里数值较大，适合采用set的方式，并且非重复，考虑时间复杂度和空间复杂度，采用unordered_set。

将第一个数组进行处理转换成set，再用numbers2遍历查询是否出现过，放在result集合里。

#include <bits/stdc++.h>
using namespace std;

vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
    unordered_set <int> result;
    unordered_set <int> nums_set(nums1.begin(), nums1.end());    //将数组1转换成哈希表

    for(int i = 0; i < nums2.size(); i++){
        if(nums_set.find(nums2[i]) != nums_set.end()){
            result.insert(nums2[i]);                            //set插入元素操作
        }
    }
    return vector <int> (result.begin(), result.end());

}

int main() {
    vector<int> nums1,nums2;
    int num;
    //nums1
    while(cin >> num) {
        nums1.push_back(num);
        // 读到换行符，终止循环
        if(getchar() == '\n') {
            break;
        }
    }
    //nums2
    while(cin >> num) {
        nums2.push_back(num);
        // 读到换行符，终止循环
        if(getchar() == '\n') {
            break;
        }
    }

    vector<int> result;
    result = intersection(nums1,nums2);

    for(int i = 0; i < result.size(); i++) {
        cout << result[i] << " ";
    }
    cout << endl;
    return 0;
}
/*************
示例1:
1 2 2 1
2 2
示例2:
4 9 5
9 4 9 8 4
 ************/

202. 快乐数

题目描述：

编写一个算法来判断一个数 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 <= n <= 2^31 - 1

思路和想法：

这里比较重要的地方，在于判断什么时候出现无限循环，即判断平方和数值重复出现。这里就是判断元素有无重复出现，就可以set来解决了。解决这道题目具体的步骤如下：

步骤一：计算数n的各个位置的平方和

步骤二：判断是否出现了1，并进行循环，如果在这个过程中，在set集合中找到元素，则证明出现循环，return false。

#include <bits/stdc++.h>
using namespace std;

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

int main() {
    int number;
    cin >> number;

    bool result;
    result = isHappy(number);

    if(result == 1){
        cout << "true" <<endl;
    }else{
        cout << "false" <<endl;
    }

    return 0;
}
/*************
示例1:
19
true
示例2:
2
false
 ************/

1. 两数之和

题目描述：

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

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

输入输出描述：

示例 1：

输入：nums = [2,7,11,15], target = 9 输出：[0,1] 解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

示例 2：

输入：nums = [3,2,4], target = 6 输出：[1,2]

示例 3：

输入：nums = [3,3], target = 6 输出：[0,1]

提示：

2 <= nums.length <= 104
-109 <= nums[i] <= 109
-109 <= target <= 109
只会存在一个有效答案

思路和想法：

在判断元素有无的同时，也要存储下标，所以这里我们采用unorderded_map。其中map结构--key（元素），value（下标）。

#include <bits/stdc++.h>
using namespace std;

vector<int> twoSum(vector<int>& nums, int target) {
    unordered_map <int,int> map;
    for(int i = 0; i < nums.size(); i++) {
        // 遍历当前元素，并在map中寻找是否有匹配的key
        auto iterm = map.find(target - nums[i]);
        if(iterm != map.end()) {
            return {iterm->second, i};
        }
        // 如果没找到匹配对，就把访问过的元素和下标加入到map中
        map.insert(pair<int, int>(nums[i], i));
    }
    return {};
}

int main() {
    vector<int> nums;
    int num;
    while(cin >> num){
        nums.push_back(num);
        if(getchar() == '\n'){
            break;
        }
    }

    int target;
    cin >> target;
    vector<int> result;
    result = twoSum(nums,target);

    for (int i = 0; i < result.size(); ++i) {
        cout << result[i] << " ";
    }
    cout << endl;
    return 0;
}
/*************
示例1:
2 7 11 15
9
示例2:
3 2 4
6
示例3：
3 3
6
 ************/

454. 四数相加 II

题目描述：

给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：

0 <= i, j, k, l < n
nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0

输入输出描述：

示例 1：

输入：nums1 = [1,2], nums2 = [-2,-1], nums3 = [-1,2], nums4 = [0,2] 输出：2

解释：两个元组如下： 1. (0, 0, 0, 1) -> nums1[0] + nums2[0] + nums3[0] + nums4[1] = 1 + (-2) + (-1) + 2 = 0 2. (1, 1, 0, 0) -> nums1[1] + nums2[1] + nums3[0] + nums4[0] = 2 + (-1) + (-1) + 0 = 0

示例 2：

输入：nums1 = [0], nums2 = [0], nums3 = [0], nums4 = [0] 输出：1

提示：

n == nums1.length
n == nums2.length
n == nums3.length
n == nums4.length
1 <= n <= 200
-2^28 <= nums1[i], nums2[i], nums3[i], nums4[i] <= 2^28

思路和想法：

将四个数组简化成两个数组，并将其中一个放入map中，key放两两数组加和值，value放数组下标。

步骤一：先构建一个哈希表（nums1），存储key以及value，key对应数组之和，value记录次数。

步骤二：nums3 + nums4，进行map查询，寻找里面是否有其相反数的映射。

#include <bits/stdc++.h>
using namespace std;

int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
    std::unordered_map<int, int> h1;
    //步骤一，构建哈希表，存储key以及value
    int size = nums1.size();
    int sum = 0;                //key---数组两两加和值
    int Ycount = 0;             //记录多少个元组满足
    for(int i = 0; i < size; i++){
        for(int j = 0; j < size; j++){
            sum = nums1[i] + nums2[j];
            h1[sum]++;
        }
    }
    //步骤二，map查询，记录次数
    for(int i = 0; i < size; i++){
        for(int j = 0; j < size; j++){
            sum = nums3[i] + nums4[j];
            auto item = h1.find(-sum);
            if(item != h1.end()){
                Ycount += h1[-sum];
            }
        }
    }
    return Ycount;
}

int main() {
    int n;
    cin >> n;
    vector<int> n1(n),n2(n),n3(n),n4(n);
    for (int i = 0; i < n; ++i) {
        cin >> n1[i];
    }
    for (int i = 0; i < n; ++i) {
        cin >> n2[i];
    }
    for (int i = 0; i < n; ++i) {
        cin >> n3[i];
    }
    for (int i = 0; i < n; ++i) {
        cin >> n4[i];
    }

    int result;
    result = fourSumCount(n1,n2,n3,n4);
    cout << result << endl;

    return 0;
}
/*************
示例1:
2
1 2
-2 -1
-1 2
0 2
示例2:
1
0
0
0
0
 ************/

383. 赎金信

题目描述：

给你两个字符串：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

提示：

1 <= ransomNote.length, magazine.length <= 105
ransomNote 和 magazine 由小写英文字母组成

思路和想法：

这里分为三个步骤。

步骤一：用哈希数组记录magzine字母出现次数
步骤二：遍历ransomNote，消耗magzine
步骤三：判断magzine是否透支（有负数），是则返回false

#include <bits/stdc++.h>
using namespace std;

bool canConstruct(string ransomNote, string magazine) {
    //因为magzine只由小写字母组成，26,采用数组哈希解决最好，不占空间的同时，查询时间也很短
    int h1[26] = {0};
    //步骤一，进行遍历,记录字母出现次数
    for(int i = 0; i < magazine.size(); i++){
        h1[magazine[i]-'a']++;
    }

    //步骤二：再对ransomNote进行遍历，对应--
    for(int i = 0; i < ransomNote.size(); i++ ){
        h1[ransomNote[i]-'a']--;
    }
    //步骤三：对数组遍历，看其是否存在负数，存在return false
    for(int i = 0; i < 26;i++){
        if(h1[i] < 0) return false;
    }
    return true;
}

int main() {
    string str1,str2;
    getline(cin,str1);
    getline(cin,str2);

    bool result;
    result = canConstruct(str1,str2);

    if(result == 1){
        cout << "true" << endl;
    }else{
        cout << "false" << endl;
    }

    return 0;
}
/*************
示例1:
a
b
示例2:
aa
ab
示例3：
aa
aab
 ************/