C++数据结构与算法——哈希表

C++第二阶段------数据结构和算法，之前学过一点点数据结构，当时是基于Python来学习的，现在基于C++查漏补缺，尤其是树的部分。这一部分计划一个月，主要利用代码随想录来学习，刷题使用力扣网站，不定时更新，欢迎关注！

文章目录

一、有效的字母异位词（力扣242）
二、两个数组的交集（力扣349）
三、快乐数（力扣202）
四、两数之和（力扣1）
[五、四数相加 II（力扣454）](#五、四数相加 II（力扣454）)
六、赎金信（力扣383）
七、三数之和（力扣15）
八、四数之和（力扣18）

一、有效的字母异位词（力扣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 仅包含小写字母

cpp 复制代码

class Solution {
public:
    bool isAnagram(string s, string t) {
        // 创建哈希数组
        int hashArray[26] = {0};
        for (int i=0;i<s.length();i++){
            hashArray[s[i]-'a']++;
        }
        for(int i=0;i<t.length();i++){
            hashArray[t[i]-'a']--;
        }
        for(int i=0;i<26;i++){
            if(hashArray[i]!=0){
                return false;
            }
        }
        return true;
    }
};

二、两个数组的交集（力扣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

cpp 复制代码

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        // 使用set hash处理
        unordered_set<int> hashSet;
        // 结果列表
        unordered_set<int> result;
        for(int i=0;i<nums1.size();i++){
            // 将nums添加
            hashSet.insert(nums1[i]);
        }
        for(int i=0;i<nums2.size();i++){
            // 找nums2[i]在不在hashset中
            if(hashSet.find(nums2[i])!=hashSet.end()){
                // 找到了
                result.insert(nums2[i]);
            }
        }
        vector<int> vectorResult(result.begin(),result.end());
        return vectorResult;
    }
};

三、快乐数（力扣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 <= 231 - 1

cpp 复制代码

class Solution {
public:
    bool isHappy(int n) {
        // 使用hashset去判断这个数是否出现
        unordered_set<int> hashset;
        while(true){
            if(n==1){
                return true;
            }
            else{
                n = getHappy(n);
                // 判断是否存在过
                if(hashset.find(n)!=hashset.end()){
                    // 存在过
                    return false;
                }
                // n存入hashset中
                hashset.insert(n);
            }

        }
    }
    int getHappy(int a){
        // 将该数替换为它每个位置上的数字的平方和。
        int sum =0;
        while(a!=0){
            int temp = a%10;
            sum+=temp*temp;
            a = a/10;
        }

        return sum;
    }
};

四、两数之和（力扣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

只会存在一个有效答案

进阶：你可以想出一个时间复杂度小于 O(n2) 的算法吗？

cpp 复制代码

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        // 使用hashmap解决
        unordered_map<int,int> hashMap;
        for(int i=0;i<nums.size();i++){
            // 计算需要的值
            int need = target-nums[i];
            if(hashMap.find(need)!=hashMap.end()){
                // 找到了
                return {hashMap[need],i};
            }
            else{
                // 将nums[i]存入hashmap中
                hashMap.insert(make_pair(nums[i],i));
            }
        }
        return {};
    }
};

五、四数相加 II（力扣454）

给你四个整数数组 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

解释：

两个元组如下：

(0, 0, 0, 1) -> nums1 $0$ + nums2 $0$ + nums3 $0$ + nums4 $1$ = 1 + (-2) + (-1) + 2 = 0

(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

-228 <= nums1 $i$ , nums2 $i$ , nums3 $i$ , nums4 $i$ <= 228

cpp 复制代码

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        // 每两个相加，通过hashmap进行存储，key为相加的值，value为出现的次数
        unordered_map<int,int> hashMapFS; // first and Second
        // 遍历前两个
        for(int i=0;i<nums1.size();i++){
            for(int j=0;j<nums2.size();j++){
                hashMapFS[nums1[i]+nums2[j]]++; // 添加次数
            }
        }
        // 遍历后两个
        int count =0;
        for(int i=0;i<nums3.size();i++){
            for(int j=0;j<nums4.size();j++){
                int sumTF = nums3[i]+nums4[j];
                int target = -sumTF;
                if(hashMapFS.find(target)!=hashMapFS.end()){
                    // 找到了
                    count += hashMapFS[target]; // 将次数添加
                }
            }
        }
        return count;
        //
    }
};

六、赎金信（力扣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 由小写英文字母组成

cpp 复制代码

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        // 使用hast数组解决，判断最后hashset中有没有<0的数即可
        int hashset[52] ={0};
        for(int i=0;i<magazine.length();i++){
            // 添加到hashset中
            hashset[magazine[i]-'a']++;
        }
        for(int i=0;i<ransomNote.length();i++){
            // 对应位置相减
            hashset[ransomNote[i]-'a']--;
        }
        // 查看有没有小于0的
        for(int i=0;i<52;i++){
            if(hashset[i]<0){
                return false;
            }
        }
        return true;
    }
};

七、三数之和（力扣15）

给你一个整数数组 nums ，判断是否存在三元组 $nums\[i$ , nums $j$ , nums $k$ ] 满足 i != j、i != k 且 j != k ，同时还满足 nums $i$ + nums $j$ + nums $k$ == 0 。请

你返回所有和为 0 且不重复的三元组。

注意：答案中不可以包含重复的三元组。

示例 1：

输入：nums = $-1,0,1,2,-1,-4$

输出： $\[-1,-1,2$ , $-1,0,1$ ]

解释：

nums $0$ + nums $1$ + nums $2$ = (-1) + 0 + 1 = 0 。

nums $1$ + nums $2$ + nums $4$ = 0 + 1 + (-1) = 0 。

nums $0$ + nums $3$ + nums $4$ = (-1) + 2 + (-1) = 0 。

不同的三元组是 $-1,0,1$ 和 $-1,-1,2$ 。

注意，输出的顺序和三元组的顺序并不重要。

示例 2：

输入：nums = $0,1,1$

输出：\[\]

解释：唯一可能的三元组和不为 0 。

示例 3：

输入：nums = $0,0,0$

输出： $\[0,0,0$ ]

解释：唯一可能的三元组和为 0 。

提示：

3 <= nums.length <= 3000

-105 <= nums $i$ <= 105

注意去重！！！

cpp 复制代码

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        // 先对数组排序
        sort(nums.begin(),nums.end());
        // 定义结果数组
        vector<vector<int>> result;
        // 剪枝操作
        if(nums[0]>0){
            return {}; // 第一个元素都大于0了，说明不可能加起来等于0，直接返回空
        }
        for(int i=0;i<nums.size();i++){
            // 定义两个指针
            int begin = i+1;
            int end = nums.size()-1;
            // 去重操作
            if(i>0&&nums[i]==nums[i-1]){
                // 当前的i和i-1的元素是一样的
                continue; // 跳过当前循环
            }
            while(begin<end){
                if((nums[i]+nums[begin]+nums[end])==0){
                    result.push_back({nums[i],nums[begin],nums[end]});
                    while(begin<end&&nums[begin]==nums[begin+1]){
                        begin++;
                    }
                    while(begin<end&&nums[end]==nums[end-1]){
                        end--;
                    }
                    begin++;
                    end--;
                }
                else if((nums[i]+nums[begin]+nums[end])>0){
                    end--;
                }
                else{
                    begin++;
                }

            }


        }
        return result;
    }
};

八、四数之和（力扣18）

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 $nums\[a$ , nums $b$ , nums $c$ , nums $d$ ] （若两个四元组元素一一对应，则认为两个四元组重复）：

0 <= a, b, c, d < n

a、b、c 和 d 互不相同

nums $a$ + nums $b$ + nums $c$ + nums $d$ == target

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

示例 1：

输入：nums = $1,0,-1,0,-2,2$ , target = 0

输出： $\[-2,-1,1,2$ , $-2,0,0,2$ , $-1,0,0,1$ ]

示例 2：

输入：nums = $2,2,2,2,2$ , target = 8

输出： $\[2,2,2,2$ ]

提示：

1 <= nums.length <= 200

-109 <= nums $i$ <= 109

-109 <= target <= 109

两层for循环，同样注意去重！

cpp 复制代码

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        // 先排序
        sort(nums.begin(),nums.end());
        // 定义最终返回数组
        vector<vector<int>> result;
        // 类似于三数之和，多了一层循环
        for (int i=0;i<nums.size();i++){
            // 剪枝
            if(nums[0]>=0&&nums[0]>target){
                break;
            }
            // 去重
            if(i>0&&nums[i]==nums[i-1]){
                continue;
            }
            for(int j=i+1;j<nums.size();j++){
                // 剪枝
                if(nums[i]+nums[j]>target&&nums[j]>=0){
                    break;
                }
                // 去重
                if(j>i+1&&nums[j]==nums[j-1]){
                    continue;
                }
                // 类似于三数之和
                int begin = j+1;
                int end = nums.size()-1;
                while(begin<end){
                    if((long) nums[i]+nums[j]+nums[begin]+nums[end]==target){
                        // 找到符合要求的数组，记录
                        result.push_back({nums[i],nums[j],nums[begin],nums[end]});
                        while(begin<end&&nums[begin]==nums[begin+1]){
                            begin++;
                        }
                        while(begin<end&&nums[end]==nums[end-1]){
                            end--;
                        }
                        begin++;
                        end--;
                    }
                    else if((long)nums[i]+nums[j]+nums[begin]+nums[end]>target){
                        end--;
                    }
                    else{
                        begin++;
                    }
                }
            }
        }
        return result;
    }
};