【力扣刷题——哈希表整理】附力扣链接、题目描述、解题方法及代码（242、383、49、438、349、350、202、1、454、15、18、）后续补充

😀如果对你有帮助的话😊
🌺为博主点个赞吧 👍
👍点赞是对博主最大的鼓励😋
💓爱心发射~💓

基础知识

来吧！一文彻底搞定哈希表！

• 哈希表是根据关键码的值而直接进行访问的数据结构。

• 一般哈希表都是用来快速判断一个元素是否出现集合里。

哈希函数

总结
总结一下，当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法。但是哈希法也是牺牲了空间换取了时间，因为我们要使用额外的数组，set或者是map来存放数据，才能实现快速的查找。

242. 有效的字母异位词——简单

力扣

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

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

示例 1:

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

示例 2:

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

代码

class Solution {
    public boolean isAnagram(String s, String t) {
        //判断是否相等
        if(s.length() != t.length()) return false;
        //存入 减去
        int[] a = new int[26];
        for(int i=0; i<s.length(); ++i){
            a[s.charAt(i)-'a']++;
            a[t.charAt(i)-'a']--;
        }

        // 判断结果是否为0
        for(int i=0; i<26; ++i){
            if(a[i] != 0) return false;
        }
        return true;
    }
}

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

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        if(ransomNote.length() > magazine.length()) return false;

        int[] a = new int[26];
        for(char i : magazine.toCharArray()){
            a[i -'a']++;
        }
        for(char i : ransomNote.toCharArray()){
            a[i-'a']--;
            if(a[i-'a'] < 0){
                return false;
            }  
        }
        return true;
    }
}

49. 字母异位词分组——中等

力扣

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

字母异位词 是由重新排列源单词的字母得到的一个新单词，所有源单词中的字母通常恰好只用一次。

示例 1:

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

示例 2:

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

示例 3:

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

1、排序

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        // 存放字符串
        Map<String, List<String>> map = new HashMap<String, List<String>>();
        for(String str : strs){
            // 将字符串换为数组
            char[] array = str.toCharArray();
            // 数组排序
            Arrays.sort(array);
            // 返回字符串
            String key = new String(array);
            // 判断数组里有字符串吗
            List<String> list = map.getOrDefault(key, new ArrayList<String>());
            list.add(str);
            map.put(key, list);
        }
        return new ArrayList<List<String>>(map.values());
    }
}

2、stream 的 grouping

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
//         // stream 的 groupingBy
//         // groupingBy 算子计算完以后，返回的是一个 Map<String, List<String>>
//         // Collector是专门用来作为Stream的collect方法的参数的。
//         // collect 可以收集流中的数据到【集合】或者数组中去
//         // groupingBy 根据字符串进行分组
        return new ArrayList<>(Arrays.stream(strs)
            .collect(Collectors.groupingBy(
                str->{
                    //将str转换为数组
                    char[] array = str.toCharArray();
                    //排序
                    Arrays.sort(array);
                    //返回排序后的数组
                    return new String(array);
                }
            )).values()
        );
    }
}

438. 找到字符串中所有字母异位词——中等

给定两个字符串 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 List<Integer> findAnagrams(String s, String p) {
        // 字符串长
        int slen = s.length();
        int plen = p.length();
        // s<p 直接返回
        if(slen < plen ){
            return new ArrayList<Integer>();
        }
        // 定义数组存索引
        List<Integer> num = new ArrayList<Integer>();
        // 定义两个数组存字符串
        int[] sCount = new int[26];
        int[] pCount = new int[26];
        
        // 先判断开始是否与p相同，返回0
        for(int i=0; i<plen; ++i){
            ++sCount[s.charAt(i)-'a'];
            ++pCount[p.charAt(i)-'a'];
        }
        if(Arrays.equals(sCount,pCount)){
            num.add(0);
        }
        // 继续判断下一位
        for(int i=0; i<slen-plen; ++i){
            --sCount[s.charAt(i)-'a'];
            ++sCount[s.charAt(i+plen)-'a'];
            if(Arrays.equals(sCount,pCount)){
                num.add(i+1);
            }
        }
        return num;
    }
}

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] 也是可通过的

方法一：两个集合

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        if(nums1==null || nums1.length==0 ||nums2==null || nums2.length==0){
            return new int[0];
        }
        Set<Integer> set1 = new HashSet<>();
        Set<Integer> resSet = new HashSet<>();
        //遍历数组1
        for(int i : nums1){
            set1.add(i);
        }
        //遍历数组2 判断哈希表中是否存在该元素
        for(int i :nums2){
            if(set1.contains(i)){
                resSet.add(i);
            }
        }
        //将字符串转换成数组
        int[] result = new int[resSet.size()];
        int index = 0;
        for(int i : resSet){
            result[index++] = i;
        }
        return result;
    }
}

350. 两个数组的交集 II——简单

力扣
给你两个整数数组 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]

方法一：哈希表

class Solution {
    public int[] intersect(int[] nums1, int[] nums2) {
        // 先循环 短的数组 将短数组存起来
         if(nums1.length > nums2.length){
            return intersect(nums2,nums1);   // 交换位置
        }
        //创建 HashMap 
        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        // 将前一个数组存进去
        // map.getOrDefault() 方法获取指定 key 对应对 value，如果找不到 key ，则返回设置的默认值
        for(int i : nums1) {
            int count = map.getOrDefault(i, 0) + 1;
            map.put(i, count);
        }
        // 循环第二个数组  有相同的数，count值减1
        // 再判断count的值是否为0，不为0，存入新的（key, value）,为0， 移除数
        int index = 0;
        int[] result = new int[nums1.length];
        for(int i:nums2){
            int count = map.getOrDefault(i, 0);
            if(count>0){
                result[index++] = i;
                count--;
                if(count>0){
                    map.put(i, count);
                }else{
                    map.remove(i);
                }
            }
        }
        // 对一个已有的数组进行截取复制,copyOfRange(原数组，开始下标，结束下标)
        return Arrays.copyOfRange(result, 0, index);
    }
}

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

方法一：用哈希集合检测循环

class Solution {
    public boolean isHappy(int n) {
        Set<Integer> seen = new HashSet<>();
        while(n != 0 && !seen.contains(n)){
            seen.add(n);
            n = getNext(n);
        }
        return n==1;
    }
    private int getNext(int n){
        int next = 0;
        while(n>0){
            int a = n % 10;
            n = n / 10;
            next += a * a;
        }
        return next;    
    }
}

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]

方法二：哈希表

class Solution {
    public int[] twoSum(int[] nums, int target) {
        // 创建一个哈希表
        // key——数   value——下标
        Map<Integer, Integer> table = new HashMap<Integer,Integer>();
        // 循环数组 1、从哈希表中看是否有数据与本数相加为target,存在直接返回数组（哈希表中数的value，与此数的坐标）
        //          2、将数存到 哈希表中
        for(int i = 0; i< nums.length; ++i){
            if(table.containsKey(target - nums[i])){
                return new int[]{table.get(target-nums[i]), i};
            }
            table.put(nums[i], i);
        }
        
        // 如果数组中不存在满足条件的数，就返回0
        return new int[0];
    }
}

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

HashMap

class Solution {
    public int fourSumCount(int[] A, int[] B, int[] C, int[] D) {
        // 判断四个数组相加为0，将数组分成两组
        // 第一组的两数之和,判断是否有这个值，先存入哈希表中  key为两数之和  value为 有这个值的次数
        // 第二组：判断这两个数和的相反数 是否在哈希表中，有result加1，
        Map<Integer,Integer> table = new HashMap<Integer,Integer>();
        int result = 0;
        //第一组
        for(int i=0; i<A.length; ++i){
            for(int j=0; j<B.length; ++j){
                int sumab = A[i]+B[j];
                if(table.containsKey(sumab)){
                    table.put(sumab,table.get(sumab)+1);
                }else{
                    table.put(sumab, 1);
                }
            }
        }
        //第二组
        for(int i=0; i<C.length; ++i){
             for(int j=0; j<D.length; ++j){
                 int sumcd = -C[i] - D[j];
                 if(table.containsKey(sumcd)){
                     result += table.get(sumcd);
                 }
             }
        }
        return result;
    }
}

15. 三数之和——中等

力扣

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有和为 0 且不重复的三元组。

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

示例 1：

输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]

示例 2：

输入：nums = []
输出：[]

示例 3：

输入：nums = [0]
输出：[]

排序 + 双指针

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> lists = new ArrayList<>();
        int len = nums.length;
        // 特殊情况的数组
        if(len<3 || nums == null) return lists;
        // 数组排序
        Arrays.sort(nums);
        // 双指针循环
        //      1、nums[i]>0 直接return，因为后边不可能等于0 
        //      2、重复元素跳过
        //      3、当 l < r，进循环，result==0，存数据，result<0,l右移。result>0，r左移
        for(int i=0; i<len; ++i){
            if(nums[i]>0) return lists;
            if(i>0 && nums[i] == nums[i-1]) continue;
            int l=i+1, r=len-1;
            while(l<r){
                int result = nums[i] + nums[l] + nums[r];
                if(result==0){
                    List<Integer> bb = new ArrayList<>();
                    bb.add(nums[i]);
                    bb.add(nums[l]);
                    bb.add(nums[r]);
                    lists.add(bb);
                    while(l<r && nums[l+1] == nums[l]) ++l;
                    while(l<r && nums[r-1] == nums[r]) --r;
                    ++l;
                    --r;
                }else if(result<0){
                    ++l;
                }else{
                    --r;
                }
            }
        }
        return lists;

    }
}

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]]

排序+双指针

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        // 根据三数之和 ——两层for循环
        // 第一个for循环第一个数，第二个for循环第二个数
        // 双指针 l-第三个数，r-第四个数
        List<List<Integer>> lists = new ArrayList<>();
        int len = nums.length;

        Arrays.sort(nums);
        for(int i=0; i<len; ++i){
            // 与上一个数相同，跳过
            if(i>0 && nums[i-1] == nums[i]){
                continue;
            }

            for(int j=i+1; j<len; ++j){
                // 去重
                if(j>i+1 && nums[j-1] == nums[j]){
                    continue;
                }

                int l = j+1, r = len-1;
                while(l < r){
                    int result = nums[i] + nums[j] + nums[l] + nums[r];
                    if(result == target){
                        List<Integer> b = new ArrayList<>();
                        b.add(nums[i]); 
                        b.add(nums[j]); 
                        b.add(nums[l]); 
                        b.add(nums[r]); 
                        lists.add(b);
                        while(l<r && nums[r-1] == nums[r]) --r;
                        while(l<r && nums[l+1] == nums[l]) ++l;

                        --r;
                        ++l;
                    }else if(result < target){
                        ++l;
                    }else{
                        --r;
                    }
                }

            }
        }
        return lists;
    }
}