Leetcode刷题--哈希表

基础知识

哈希表： 数组 + 链表

作用：能快速判断一个元素是否存在一个集合中。 时间复杂度是： O(1)。

原理：因为使用了哈希算法，可以计算key的哈希值，然后映射到链表中，通过数组下标快速的访问到这个元素。 最简单的映射关系： 下标 = hash值 % tableSize。

问题：会出现Hash冲突，就是计算不同的key得到同一个值，放到数组的同一个下标，即发生了Hash冲突。

解决方案：

(1)拉链法：冲突的元素直接变量链表。这个要防止链表的长度太长了，影响查询的效率。

(2)线性探测法： 冲突的时候，将计算的Hash值继续往下排列，移到数组的下一个下标位置，不形成链表。 这个要要数组的大小大于总元素的个数。

类型一 数组也是特殊的哈希表

第1题 ： 242. 有效的字母异位词

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

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

题目翻译： 这个题翻译说来就是看这两个字符串的字符是不是全部都相同，个数也都必须全部相同。

思路： (1)直接使用HashMap是最简单的想法。
(2)数组其实也是特殊的 哈希表。因为只有26个小写字符，数组的大小就定义为26，一个很关键的问题是怎么把 字符 映射到对应的数组下标，比如：a 就是 0。

题解
暴力使用HashMap：

class Solution {
    public boolean isAnagram(String s, String t) {
        //这里就是判断t和s的字符是不是完全相等
        //HashMap把t和s的字符统计
        HashMap<Character,Integer> sMap = new HashMap<>();
        HashMap<Character,Integer> tMap = new HashMap<>();

        for(int i = 0; i < s.length(); ++i){
            sMap.put(s.charAt(i), sMap.getOrDefault(s.charAt(i), 0) + 1);
        }

        for(int i = 0; i < t.length(); ++i){
            tMap.put(t.charAt(i), tMap.getOrDefault(t.charAt(i), 0) + 1);
        }

        //遍历tMap，看是否所有字符都和s的相同
        for(Character cur : tMap.keySet()){
            if(!tMap.get(cur).equals(sMap.get(cur))){
                return false;
            }else{
                sMap.remove(cur);
            }
        }

        if(sMap.size() != 0){
            return false;
        }

        return true;
    }
}

数组形式：

class Solution {
    public boolean isAnagram(String s, String t) {
        //数组其实也是 哈希表， 小写字母只有26个
        //s字符的时候++，t字符的时候--，最后判断是不是所有位置都为0即可
        int[] arr = new int[26];

        //处理s字符串 --> 注意字符和数组下标的映射，使用 s.charAt(i) - 'a'
        for(int i = 0; i < s.length(); ++i){
            arr[s.charAt(i) - 'a']++;
        }

        //处理t字符串
        for(int i = 0; i < t.length(); ++i){
            arr[t.charAt(i) - 'a']--;
        }

        //看数组是不是都为0
        for(int i = 0; i < arr.length; ++i){
            if(arr[i] != 0){
                return false;
            }
        }

        return true;
    }
}

第2题： 383. 赎金信

题目描述：
给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。
如果可以，返回 true ；否则返回 false 。
magazine 中的每个字符只能在 ransomNote 中使用一次。

题目翻译： 与上一题不同，这个题翻译说来就是看 magazine 的字符是不是能囊括 ransomNote 的所有字符。

思路： 直接使用数组 来代替 HashMap 完成。

题解

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        //这个就是看 magazine 的字符是不是包含  ransomNote  所有的字符
        //数组也是特殊的哈希表
        int[] arr = new int[26];

        //处理字符串magazine
        for(int i = 0; i < magazine.length(); ++i){
            arr[magazine.charAt(i) - 'a']++;
        }

        //处理字符串ransomNote
        for(int i = 0; i < ransomNote.length(); ++i){
            arr[ransomNote.charAt(i) - 'a']--;
        }

        //看数组里面所有的是不是都 > 0
        for(int i = 0; i < arr.length; ++i){
            if(arr[i] < 0){
                return false;
            }
        }

        return true;
    }
}

上面的最后两个for循环可以放在一起进行处理：

//处理字符串ransomNote
        for(int i = 0; i < ransomNote.length(); ++i){
        	if(arr[ransomNote.charAt(i) - 'a'] > 0){
				arr[ransomNote.charAt(i) - 'a']--;
			}else{
				return false;
			}
        }

第3题： 49. 字母异位词分组

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

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

分析： 这题是难题较大的一题，我认为关键的问题是 ： 有这么多的字符串，要怎么确定这些字符串会是字母异位词，若直接使用HashMap<Character, Integer>，显然不现实，因为这么多字符串，每一个都要进行处理，你会得到很多的HashMap，你要对不同的map去判断他们的字符数是不是相同，感觉起来就是非常不靠谱的事。
字母异位词，我们要深究他的概念，如果是字母异位词，那么所有字符数都是相等的。这样我们是不是可以使用对字符串进行排序来判断，不需要字符的个数。 将排序后的字符串作为Map的key，而将结果List<String>作为value。

思路： 使用HashMap。

题解

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        //使用HashMap，关键问题是怎么确定 这个字符串和其他的字符串是字母异位词
        //如果HashMap的key使用Character,这样肯定会特别麻烦
        //另外，我们应该考虑到对字符串进行排序，这样如果是字母异位词，排序后肯定是相同的。
        //将HashMap设计成HashMap<String, List<String>>

        //总结果
        List<List<String>> res = new ArrayList<>();

        //创建HashMap
        HashMap<String, List<String>> map = new HashMap<>();

        //遍历字符数组
        for(String str : strs){
            //字符串转成字符数组，方便排序
            char[] strChar = str.toCharArray();
            //排序
            Arrays.sort(strChar);
            //得到排序后字符串  --> 这里要使用new String(),不能使用toString()，因为没有重写
            String newStr = new String(strChar);

            //拿排序后的字符串去map中查看--> 如果这个字符串是第一次，就创建出一个
            List<String> sList = map.getOrDefault(newStr, new ArrayList<String>());
            //然后把 未排序的字符串加入，并放入map中
            sList.add(str);
            map.put(newStr, sList);
        }

        //处理map，变成我们的结果
        for(Map.Entry<String, List<String>> entry : map.entrySet()){
            res.add(entry.getValue());
        }

        return res;
    }
}

上面存在一些巧妙处理的地方，可以多消化消化。

还有遍历map的几种方式也要掌握。除了上面这样方式，还有一种较为常见的方式，使用map.keySet()，得到所有的key集合。

第4题： 438. 找到字符串中所有字母异位词

题目描述：
给定两个字符串 s 和 p，找到 s 中所有 p 的 异位词 的子串，返回这些子串的起始索引。不考虑答案输出的顺序。
异位词 指由相同字母重排列形成的字符串（包括相同的字符串）

分析： 这题和上面一题非常像。这是这里变成了字符串，并且要返回的是满足条件的下标开始位置。

思路： (1)通过截取字符串暴力。
(2)可以使用数组模拟哈希表，然后采用滑动窗口的方式求解。

题解
暴力方式

class Solution {
    public List<Integer> findAnagrams(String s, String p) {
        //这题和 49.字母异位词分组  非常像
        //可以对s字符串截取p长度

        //结果
        List<Integer> res = new ArrayList<>();
        //先对p进行排序
        char[] cp = p.toCharArray();
        Arrays.sort(cp);
        String newP = new String(cp);

        //字符串p的长度
        int pLen = p.length();
        //遍历字符串s，截取字符串进行判断
        for(int i = 0; i <= s.length() - pLen; ++i){
            //从s中截取子串
            String curS = s.substring(i, i + pLen);
            //排序
            char[] sp = curS.toCharArray();
            Arrays.sort(sp);
            if(newP.equals(new String(sp))){
                res.add(i);
            }
        }

        return res;
    }
}

使用数组的方式：

class Solution {
    public List<Integer> findAnagrams(String s, String p) {
        //滑动窗口方法
        int slen = s.length();
        int plen = p.length();
        List<Integer> result = new ArrayList<>();
        if(slen < plen) return result;
        //数组记录s和p字符出现的个数
        int[] sarr = new int[26];
        int[] parr = new int[26];
        //遍历p，把p加入到parr中，顺便处理s的前p个字符
        for(int i = 0; i < p.length(); ++i){
            parr[p.charAt(i) - 'a'] += 1;
            sarr[s.charAt(i) - 'a'] += 1;
        }
        //判断p的第一个长度是不是
        if(Arrays.equals(sarr, parr)){
            result.add(0);
        }
        //判断从0下标开始之后的,使用滑动窗口方法。i为右指针，i-plen为窗口的左指针
        //对p后面的每个字符进行遍历，每次循环的时候，将右指针的字符加上，同时左指针的字符减去，就相当于是一个滑动窗口
        for(int i = plen; i < slen; ++i){
            sarr[s.charAt(i) - 'a'] += 1; //加上前一个字符
            sarr[s.charAt(i-plen) - 'a'] -= 1; //减去最后一个字符
            if(Arrays.equals(sarr,parr)){
                result.add(i - plen + 1);
            }
        }
        return result;
    }
}

第5题 ： 349. 两个数组的交集

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

题目翻译： 找到他们公有的元素，并且不重复。

思路： 使用HashSet就没错。

题解

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        //要去重，判断一个元素是不是再两个数组里面都有
        //使用HashSet最为合适
        HashSet<Integer> set1 = new HashSet<>();
        for(int num : nums1){
            set1.add(num);
        }

        //存储结果
        HashSet<Integer> res = new HashSet<>();
        for(int num : nums2){
            if(set1.contains(num)){
                res.add(num);
            }
        }

        int[] ans = new int[res.size()];
        int count = 0;
        for(Integer num : res){
            ans[count++] = num;
        }

        return ans;

    }
}

第6题 ： 350. 两个数组的交集 II

题目描述：
给你两个整数数组 nums1 和 nums2 ，请你以数组形式返回两数组的交集。返回结果中每个元素出现的次数，应与元素在两个数组中都出现的次数一致（如果出现次数不一致，则考虑取较小值）。可以不考虑输出结果的顺序。

题目翻译： 和上题的区别是： 这里的结果不能去重。

思路： 因为不能去重，就不能使用HashSet了，要使用HashMap。

题解

class Solution {
    public int[] intersect(int[] nums1, int[] nums2) {
        //与349题非常类似，但是这里的结果是不能去重的，那就使用HashMap
        HashMap<Integer,Integer> map1 = new HashMap<>();
        for(int num : nums1){
            map1.put(num, map1.getOrDefault(num, 0) + 1);
        }

        //结果集
        List<Integer> res = new ArrayList<>();
        //遍历第二个数组，在map1存在就加入res，map1--。
        for(int num : nums2){
            //存在才需要处理，不存在直接跳过
            if(map1.containsKey(num)){
                //放入
                res.add(num);
                //map1--
                map1.put(num, map1.get(num) - 1);
                //已经没了
                if(map1.get(num) == 0){
                    map1.remove(num);
                }
            }
        }

        //遍历res
        int[] ans = new int[res.size()];
        for(int i = 0; i < res.size(); ++i){
            ans[i] = res.get(i);
        }

        return ans;

    }
}

此外，还可以使用排序 + 双指针的方式。

class Solution {
    public int[] intersect(int[] nums1, int[] nums2) {
        //使用双指针法，  但是要提前进行排序
        Arrays.sort(nums1);
        Arrays.sort(nums2);

        int len1 = nums1.length;  int len2 = nums2.length;
        //遍历下标
        int index1 = 0; int index2 = 0; int index = 0;
        //创建结果数据，以小的为大小
        int[] res = new int[len1 > len2 ? len2 : len1];

        while(index1 < len1 && index2 < len2){
            if(nums1[index1] < nums2[index2]){
                index1++;
            }else if(nums1[index1] > nums2[index2]){
                index2++;
            }else{
                //相等的情况
                res[index++] = nums1[index1];
                index1++;
                index2++;
            }
        }

        //从res中处理得到最终结果
        return Arrays.copyOfRange(res, 0, index);
    }
}

第7题 ： 202. 快乐数

题目描述：
编写一个算法来判断一个数 n 是不是快乐数。

「快乐数」定义为：

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

如果 n 是快乐数就返回 true ；不是，则返回 false 。

思路： 要理解快乐数， 里面有一个点，会出现无限循环，无限循环就是会出现重复，重复就使用HashSet，可以这样： 只要 n != 1，就一直循环，直到找到1为止。 然后在循环里面去看这个n是否重复，不重复，就加入并更新n的值，重复那就是不限循环，return false。
还有一个关键点是： 给你一个数，你怎么样能拿到这个数的所有位置上的数，这样要掌握。

题解

class Solution {
    public boolean isHappy(int n) {
        //如果出现无限循环，那就是结果会重复，重复就用HashSet
        //还有一个关键是：  给你一个数，你怎么获得这个数每个位置上的数值分别是什么
        HashSet<Integer> set = new HashSet<>();

        //只要不是1就一直找
        while(n != 1){
            //看是否n重复了 --> 无限循环
            if(set.contains(n)){
                return false;
            }
            //加入
            set.add(n);
            //没有重复，要处理这个n，拿到所有位置的数
            //记录n每个位置数平方和后的结果
            int temp = 0;
            while(n > 0){
                //循环取每一位数值， 从 个位 -> 十位 -> 百位
                int num = n % 10;
                temp += num * num;
                //更新n，才能取到下一位的
                n = n / 10;
            }
            //进行下一轮循环
            n = temp;
        }

        //n == 1
        return true;
    }
}

关键：给你一个数，怎么获取 个位、十位、百位。。。上的每一个数值大小。

/*
 * 这个num就是不断更新，从 个位 -> 十位 -> 百位。。一直取，直至取完为止
 */
while(n > 0){
	//循环取每一位数值， 从 个位 -> 十位 -> 百位
	int num = n % 10;
	//更新n，才能取到下一位的
	n = n / 10;
}

第8题 ： 1. 两数之和

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

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

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

思路：
(1)两层for暴力。
(2)使用HashMap，可以记录元素的下标位置。

题解

class Solution {
    public int[] twoSum(int[] nums, int target) {
        //使用HashMap，因为要返回的是数组的下标位置
        HashMap<Integer,Integer> map = new HashMap<>();

        for(int i = 0; i < nums.length; ++i){
            int cur = nums[i];
            //找到
            if(map.containsKey(target - cur)){
                return new int[]{i, map.get(target - cur)};
            }else{
                map.put(cur, i);
            }
        }

        //没有
        return new int[0];
    }
}

第9题 ： 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

思路：
使用组合的方式，有4个不同的数组，将两两数组进行组合，1和2的sum组合放到map中，然后去3和4的sum中找是否存在让四个数的结果为0的。

题解

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        //使用HashMap对四个数组进行两两分组。 要记录次数
        HashMap<Integer,Integer> map = new HashMap<>();
        //1和2的结果分为一组，放到map中，然后查看3和4中是不是能找到map中对应的数
        for(int num1 : nums1){
            for(int num2 : nums2){
                //和加入map
                int sum = num1 + num2;
                map.put(sum, map.getOrDefault(sum, 0) + 1);
            }
        }

        //记录结果
        int res = 0;
        //3和4分成一组
        for(int num3 : nums3){
            for(int num4 : nums4){
                int sum = num3 + num4;
                if(map.containsKey(0 - sum)){
                    res += map.get(0 - sum);
                }
            }
        }

        return res;
    }
}

第10题 ： 15. 三数之和

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

思路：
使用三指针法。 一个指针下标i去遍历数组，这是第一个数。 下标i+1作为左边界，下标length-1作为右边界，他们分别是第二个和第三个数。 然后根据sum的值不断去更新这些下标。这就是三指针法。
一个关键的问题是： 要去重！！！

题解

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        //三指针法。 外层for从前向后遍历，然后下标从前往后，另外一个下标从后往前，要考虑去重问题
        List<List<Integer>> res = new ArrayList<>();
        //先排序  --> 排序是为了去重做准备
        Arrays.sort(nums);

        //遍历
        for(int i = 0; i < nums.length - 2; ++i){
            //sum肯定 > 0
            if(nums[i] > 0){
                return res;
            }

            //去重
            if(i > 0 && nums[i] == nums[i-1]){
                continue;
            }

            //另外两个下标
            int left = i + 1, right = nums.length - 1;
            while(left < right){
                //三数之和
                int sum = nums[i] + nums[left] + nums[right];
                if(sum < 0){
                    left++;
                }else if(sum > 0){
                    right--;
                }else{
                    //和为0，那么第一次出现的就加入，在下面进行去重操作
                    res.add(Arrays.asList(nums[i], nums[left], nums[right]));

                    //left下标的去重
                    while(left < right && nums[left] == nums[left+1]){
                        left++;
                    }

                    //right下标的去重
                    while(left < right && nums[right] == nums[right-1]){
                        right--;
                    }

                    //更新left和right的下标
                    left++;
                    right--;
                }
            }

        }
        return res;
    }
}

第11题 ： 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

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

思路：
这个和上一题基本一样，就是多了一个数，所以将问题变成和上面一样就解决了。这样，我们就可以使用四指针法，然后和上面一样的方式解决问题。

题解

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        //可以这题处理成  第15题. 三数之和  类似的问题。  就是要先处理好两个数的和，这样就变成了15题。
        List<List<Integer>> res = new ArrayList<>();
        //排序，方便去重
        Arrays.sort(nums);

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

                //计算出3和4的和应该是多少
                int sum = target - nums[i] - nums[j];  

                //另外两个下标
                int left = j + 1, right = nums.length - 1;
                while(left < right){
                    int sumlr = nums[left] + nums[right];
                    if(sum > sumlr){
                        //和太小了
                        left++;
                    }else if(sum < sumlr){
                        right--;
                    }else{
                        //相等，加入，然后去重
                        res.add(Arrays.asList(nums[i], nums[j], nums[left], nums[right]));

                        //left去重
                        while(left < right && nums[left] == nums[left+1]){
                            left++;
                        }

                        //right去重
                        while(left < right && nums[right] == nums[right-1]){
                            right--;
                        }

                        //更新坐标
                        left++;
                        right--;
                    }
                }
            }
        }

        return res;
    }
}

总结

(1)数组是特殊的哈希表，如果个数确定，就可以使用数组代替哈希表。
(2)如果有去重操作，那就使用HashSet； 如果不需要去重，并且还要将所有的结果都进行展示，那就使用HashMap。