03.Leetcode刷题：哈希表专题

Jackson96

已于 2024-01-14 19:42:50 修改

阅读量45

点赞数

分类专栏： Leetcode刷题记录--代码随想录文章标签： leetcode 哈希算法

于 2023-10-17 23:03:22 首次发布

本文链接：https://blog.csdn.net/Jackson96/article/details/133829993

版权

Leetcode刷题记录--代码随想录专栏收录该内容

6 篇文章 0 订阅

订阅专栏

题目一：有效的字母异同位

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
示例 1: 输入: s = “anagram”, t = “nagaram” 输出: true
示例 2: 输入: s = “rat”, t = “car” 输出: false
说明: 你可以假设字符串只包含小写字母。
解题思路：
解法一：暴力解法两层for循环，同时还要记录字符是否重复出现、
解法二：哈希表
数组其实就是一个简单哈希表，而且这道题目中字符串只有小写字符，那么就可以定义一个数组，来记录字符串s里字符出现的次数。题目中描述，字符串只包含小写字母，因此可以定义一个数组元素数量为26的数组。由于字符a到字符z的ASCII是26个连续的数值，所以字符a映射为下标0，相应的字符z映射为下标25。再遍历字符串s的时候，只需要将 s[i] - ‘a’ 所在的元素做+1 操作即可，并不需要记住字符a的ASCII，只要求出一个相对数值就可以了。这样就将字符串s中字符出现的次数，统计出来了。因为字母是连续的，放在哈希表中也是连续的，所以hash[0]就是a，s[i]-'a’就是对应在哈希表中的下标。
然后再使用一次for循环，检查字符串t中是否出现了这些字符，同样在遍历字符串t的时候，对t中出现的字符映射哈希表索引上的数值再做-1的操作。最后检查一下，record数组如果有的元素不为零0，说明字符串s和t一定是谁多了字符或者谁少了字符，return false。最后如果record数组所有元素都为零0，说明字符串s和t是字母异位词，return true。

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']++;
        }
        for (int i=0; i<t.size(); i++)
        {
            hash[t[i] - 'a']--;
        }
        for (int i=0; i<26; i++)
        {
            if (hash[i] != 0)
                return false;
        }
        return true;
    }
};

题目二.两个数组的交集

在这里插入图片描述
解题思路：
解法一：利用数组实现哈希表
本题的思路主要是这样的，先将nums1的所有元素放入哈希表当中，然后再将nums2中的数据与哈希表中的数据进行比较，最后返回结果。

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result_set;//用来存放结果，会自动对元素去重
        int hash[1005] = {0}; 
        for (int i=0; i<nums1.size(); i++)
        {
            hash[nums1[i]] = 1;//将nums1中的元素放入哈希表，nums1[i]对应的是哈希表的下标，比如nums1[10]=9，那么hash[9]=1
        }
        for (int i=0; i<nums2.size(); i++)
        {
            if (hash[nums2[i]] == 1)//nums2[i]也是下标，比如nums2[2]=9且hash[9]=1，那么9这个元素就是num1和nums2都有的元素
                result_set.insert(nums2[i]);
        }
        return vector<int>(result_set.begin(), result_set.end());
    }
};

方法二：利用set实现哈希表
解题思路与用数组实现是一致的，先将nums1放入哈希表，然后遍历，看num2中的元素在哈希表中有没有出现过

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 i=0; i<nums2.size(); i++)
        {
            if (nums_set.find(nums2[i]) != nums_set.end())
                result_set.insert(nums2[i]);
        }
        return vector<int>(result_set.begin(), result_set.end());
    }
};

题目三：两数之和

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那两个整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]
解题思路：
根据题意，当我们需要查询一个元素是否出现过，或者一个元素是否在集合里的时候，就要第一时间想到哈希法。本题我就需要一个集合来存放我们遍历过的元素，然后在遍历数组的时候去询问这个集合，某元素是否遍历过，也就是是否出现在这个集合。本题，我们不仅要知道元素有没有遍历过，还要知道这个元素对应的下标，需要使用 key value结构来存放，key来存元素，value来存下标，那么使用map正合适。
确定好使用map之后需要明确两点：**其一，map是用来存放我们访问过的元素；其二，数组中的元素作为key，value用来存下标。**这道题我们需要给出一个元素，判断这个元素是否出现过，如果出现过，返回这个元素的下标，那么判断元素是否出现，这个元素就要作为key。所以 map中的存储结构为 {key：数据元素，value：数组元素对应的下标}。在遍历数组的时候，只需要向map去查询是否有和目前遍历元素匹配的数值，如果有，就找到的匹配对，如果没有，就把目前遍历的元素放进map中，因为map存放的就是我们访问过的元素。
代码：

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        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};
            }else
            {
                map.insert(pair<int,int>(nums[i],i));// 如果没找到匹配对，就把访问过的元素和下标加入到map中
            }
        }
        return {};
    }
};

题目四.四数相加II

给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 (i, j, k, l) ，使得 A[i] + B[j] + C[k] + D[l] = 0。
为了使问题简单化，所有的 A, B, C, D 具有相同的长度 N，且 0 ≤ N ≤ 500 。所有整数的范围在 -2^28 到 2^28 - 1 之间，最终结果不会超过 2^31 - 1 。
例如:
输入:
A = [ 1, 2]
B = [-2,-1]
C = [-1, 2]
D = [ 0, 2]
输出:
2
解释:
两个元组如下:
(0, 0, 0, 1) -> A[0] + B[0] + C[0] + D[1] = 1 + (-2) + (-1) + 2 = 0
(1, 1, 0, 0) -> A[1] + B[1] + C[0] + D[0] = 2 + (-1) + (-1) + 0 = 0

解题思路：
这道题目是四个独立的数组，只要找到A[i] + B[j] + C[k] + D[l] = 0就可以，不用考虑有重复的四个元素相加等于0的情况。在哈希表章节的第一题当中，我们使用数组构造哈希表，并采用了两个for循环，第一个for循环是将数据放进哈希表中，第二个for循环是去哈希表中找，看是否有符合条件的数值。在这里，可以采用类似的方法进行求解。将A和B两个数组看为一个整体，C和D看为一个整体，即考虑A+B和C+D。
本题解题步骤：
1.首先定义一个unordered_map，key放a和b两数之和，value 放a和b两数之和出现的次数。
2.遍历大A和大B数组，统计两个数组元素之和，和出现的次数，放到map中。
3.定义int变量count，用来统计 a+b+c+d = 0 出现的次数。
4.在遍历大C和大D数组，找到如果 0-(c+d) 在map中出现过的话，就用count把map中key对应的value也就是出现次数统计出来。
5.最后返回统计值 count 就可以了

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        int n = nums1.size();
        int sum = 0;
        unordered_map<int,int> map;
        for (int i=0; i<n; i++)
        {
            for (int j=0; j<n; j++)
            {
                map[nums1[i]+nums2[j]]++;
            }
        }
        for (int i=0; i<n; i++)
        {
            for (int j=0; j<n; j++)
            {
                if (map.find(0-nums3[i]-nums4[j]) != map.end())
                {
                    sum += map[0-nums3[i]-nums4[j]];
                }
            }
        }
        return sum;
    }
};

题目五.三数之和

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。
注意：答案中不可以包含重复的三元组。
示例：
给定数组 nums = [-1, 0, 1, 2, -1, -4]，
满足要求的三元组集合为： [ [-1, 0, 1], [-1, -1, 2] ]
解题思路：
双指针法：首先对这个数组进行排序，然后最外层使用一个for循环，从第一个位置开始遍历，下标为i，定义一个left在i+1的位置上，定义一个right在数组结尾的位置上，题意是a+b+c=0，我们就将他转换成了寻找nums[i]+nums[left]+nums[right]=0。如果nums[i]+nums[left]+nums[right]>0，这就说明此时三数之和大了，right需要左移；如果nums[i]+nums[left]+nums[right]<0，这就说明此时三数之和小了，left需要右移；就这样不断移动，知道left与right相遇。
本题思路并不复杂，主要关注点在去重这个操作。
去重a：判断条件为（i>0 && nums[i]==nums[i-1]）
去重left：判断条件为（right>left && nums[left]==nums[left+1]）
去重right：判断条件为（right>left && nums[right]==nums[right-1]）
代码：

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> result;
        sort(nums.begin(), nums.end());

        for (int i=0; i<nums.size(); i++)
        {
            if (nums[i] > 0)
            {
                return result;// 排序之后如果第一个元素已经大于零，那么无论如何组合都不可能凑成三元组，直接返回结果就可以了
            }
            if (i>0 && nums[i]==nums[i-1])
            {
                continue;
            }
            int left = i + 1;
            int right = nums.size() - 1;

            while (right > left)
            {
                if (nums[i]+nums[left]+nums[right] > 0)
                {
                    right--;
                }else if (nums[i]+nums[left]+nums[right] < 0)
                {
                    left++;
                }else
                {
                    result.push_back(vector<int>{nums[i], nums[left], nums[right]});// 去重逻辑应该放在找到一个三元组之后，对b 和 c去重
                    while (right>left && nums[right]==nums[right-1]) right--;
                    while (right>left && nums[left]==nums[left+1]) left++;
                    // 找到答案时，双指针同时收缩
                    left++;
                    right--;
                }
            }
        }
        return result;
    }
};

题目六.四数之和

题意：给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。
注意：
答案中不可以包含重复的四元组。
示例：给定数组 nums = [1, 0, -1, 0, -2, 2]，和 target = 0。满足要求的四元组集合为： [ [-1, 0, 0, 1], [-2, -1, 1, 2], [-2, 0, 0, 2] ]
解题思路：
四数之和和三数之和采用的是同一个思路，双指针法，具体就是在三数之和的代码框架上再加一层for循环。但是还是有些区别，例如：不要判断nums[k] > target 就返回了，三数之和可以通过 nums[i] > 0 就返回了，因为 0 已经是确定的数了，四数之和这道题目 target是任意值。比如：数组是[-4, -3, -2, -1]，target是-10，不能因为-4 > -10而跳过。但是我们依旧可以去做剪枝，逻辑变成nums[i] > target && (nums[i] >=0 || target >= 0)就可以了。
四数之和的双指针解法是两层for循环nums[k] + nums[i]为确定值，依然是循环内有left和right下标作为双指针，找出nums[k] + nums[i] + nums[left] + nums[right] == target的情况。那么一样的道理，五数之和、六数之和等等都采用这种解法。
代码：

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> result;
        sort(nums.begin(), nums.end());
        for (int k=0; k<nums.size(); k++)
        {
        	// 剪枝处理
            if (nums[k]>target && nums[k]>=0)
            {
                break;// 这里使用break，统一通过最后的return返回
            }
            // 对nums[k]去重
            if (k>0 && nums[k]==nums[k-1])
            {
                continue;
            }
            for (int i=k+1; i<nums.size(); i++)
            {
            	// 2级剪枝处理
                if (nums[k]+nums[i]>target && nums[k]+nums[i]>=0)
                {
                    break;
                }
                // 对nums[i]去重
                if (i>k+1 && nums[i]==nums[i-1])
                {
                    continue;
                }
                int left = i + 1;
                int right = nums.size() - 1;
                while (right > left)
                {
                    if ((long)nums[k]+nums[i]+nums[left]+nums[right] > target)
                    {
                        right--;
                    }else if ((long)nums[k]+nums[i]+nums[left]+nums[right] < target)
                    {
                        left++;
                    }else
                    {
                        result.push_back(vector<int>{nums[k],nums[i],nums[left],nums[right]});
                        // 对nums[left]和nums[right]去重
                        while (right>left && nums[right]==nums[right-1])    right--;
                        while (right>left && nums[left]==nums[left+1])    left++;
						// 找到答案时，双指针同时收缩
                        left++;
                        right--;
                    }
                }
            }
        }
        return result;
    }
};

Jackson96

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
03.Leetcode刷题：哈希表专题

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。示例 1: 输入: s = “anagram”, t = “nagaram” 输出: true示例 2: 输入: s = “rat”, t = “car” 输出: false说明: 你可以假设字符串只包含小写字母。解法一：暴力解法两层for循环，同时还要记录字符是否重复出现、解法二：哈希表数组其实就是一个简单哈希表，而且这道题目中字符串只有小写字符，那么就可以定义一个数组，来记录字符串s里字符出现的次数。
复制链接

扫一扫