算法笔记（Java）——哈希表篇

一般哈希表都是用来快速判断一个元素是否出现集合里，哈希表并不意味着一定要使用HashMap，有时候使用数组更方便，有时候要使用set，依据具体情况而定，哈希表是典型的空间换时间。

数组作为哈希表

一些应用场景就是为数组量身定做的，最常见的是要求只有小写数组，最适合用数组作为哈希表

242.有效的字母异位词

该题让我们统计两个字符串中的字符是否数量一样，都是小写字母，直接用数组来统计最合适。

/**
 * 242. 有效的字母异位词 字典解法
 * 时间复杂度O(m+n) 空间复杂度O(1)
 */
class Solution {
    public boolean isAnagram(String s, String t) {
        int[] record = new int[26];

        for (int i = 0; i < s.length(); i++) {
            record[s.charAt(i) - 'a']++;     // 并不需要记住字符a的ASCII，只要求出一个相对数值就可以了
        }

        for (int i = 0; i < t.length(); i++) {
            record[t.charAt(i) - 'a']--;
        }
        
        for (int count: record) {
            if (count != 0) {               // record数组如果有的元素不为零0，说明字符串s和t 一定是谁多了字符或者谁少了字符。
                return false;
            }
        }
        return true;                        // record数组所有元素都为零0，说明字符串s和t是字母异位词
    }
}

还有一道相似的题，与上一题的区别是a字符串中字符的数量要被b字符串包含

383. 赎金信

Set作为哈希表

力扣题目链接

349. 两个数组的交集

HashSet常用API：

1. set.add() :用于往hashSet中添加元素
2. set.remove():用于删除hashSet中的元素
3. set.contains():用于判断这个元素在不在hashSet中

本题判断两个数组的交集，只要在一个数组中出现一次，就可以记录到hashSet中：

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        int length = nums1.length>nums2.length?nums2.length:nums1.length;
        int[] result = new int[length];
        int count = 0;
        HashSet<Integer> set = new HashSet<>();
        for (int i = 0; i < nums1.length; i++) {
            if (!set.contains(nums1[i])){
                set.add(nums1[i]);
            }
        }
        for (int i = 0; i < nums2.length; i++) {
            if (set.contains(nums2[i])){
                result[count++] = nums2[i];
                set.remove(nums2[i]);
            }
        }
          return Arrays.copyOfRange(result,0,count);
    }
}

Map作为哈希表

力扣题目链接：

1. 两数之和

HashMap常用API：

1. map.put(key,value):存一个键值对
2. map.get(key):根据key获取value
3. map.containsKey():查找有没有对应的key
4. map.getOrDefault(key,defaultValue):获得key对应的value，如果没有获得默认值

这种题目需要使用key value结构，单纯的Set已经不再适用。两数之和，存起来的key是target减去当前数组中的元素，value是对应的位置，这样到下一个元素，用当前元素的数值就可以判断有没有符合条件的结果了。

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer,Integer> map = new HashMap<>();
        for(int i=0;i<nums.length;i++){
            if(map.containsKey(nums[i])){
                int result1 = map.get(nums[i]);
                return new int[]{result1,i};
            }
            else{
                map.put(target-nums[i],i);  // 如果这个不是结果，存起来，key是target-当前值，value是当前值的位置
            }
        }
        return null;
    }
}

几数之和系列

几数之和类的题目不一定适合使用哈希表，有些用双指针加去重的方式比较好。

适用于使用哈希表的题

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

由于本题是在四个数组中寻找满足四个数为0的元组数，不涉及去重问题，所以可以使用HashMap，前两个数组中的和作为放入map中，value是该和的出现次数，然后在第3、4个数组中 根据两个和的负数作为key去map中查，查到了就作为结果的一部分。

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
Map<Integer,Integer> map =new HashMap<>();
int result=0;
for (int i:nums1){
	for (int j:nums2){
map.put(i+j,map.getOrDefault(i+j,0)+1);
	}
}
for (int u:nums3){
	for (int v:nums4){
if (map.containsKey(-u-v)){
result+=map.get(-u-v);}
    }
}
return result;
    }
}

不适用哈希表，需要双指针加去重的

在几数之和类的题目中，如果是在一个数组中寻找几数之和，那么用哈希表的方法就比较麻烦，使用双指针（其实是多指针）外加考虑去重的方法是最好的。

步骤大概为：

1. 将数组排序，想要后续去重，使用双指针，就一定要对数组排序。
2. 遍历数组，三数之和就用一个索引外加两个指针遍历，四数之和就用两个索引外加两个指针遍历。
3. 去重，每一个数都要去重，但是去重的规则是不一样的。

力扣题目：

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] 。
注意，输出的顺序和三元组的顺序并不重要。

本题使用哈希表来解决并不好做，因为要考虑去重的一系列问题，所以使用双指针法。

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        Arrays.sort(nums);  // 先给数组排序
        int left,right;  // 两个指针，一个索引，就是共计三个指针来确定三个数
        int len = nums.length;
        for(int i=0;i<len;i++){
            if(nums[i]>0){
                return result;
            }
            if(i>0 && nums[i]==nums[i-1]){ // a的去重
                continue;
            }
            left = i+1;
            right = len-1;
            while(left<right){
                if(nums[i]+nums[left]+nums[right]<0){
                    left++; 
                } else if(nums[i]+nums[left]+nums[right]>0){
                    right--;
                } else {
                    List<Integer> temp = new ArrayList<>();
                    temp.add(nums[i]);
                    temp.add(nums[left]);
                    temp.add(nums[right]);
                    result.add(temp);
                    while(left<right && nums[left] == nums[left+1]) left++;  // b，c的去重
                    while(left<right && nums[right] == nums[right-1]) right--; 
                    left++;
                    right--;
                }
              
            }
        }
        return result;

}
}

注意 a,b,c三个数的去重是有些不一样的，因为a是第一个数，要用nums[i]==nums[i-1]来判断重复，而不是判断i和i+1，就是不能判断下一个而是要判断上一个，为的就是怕（-1，-1，2）这种结果漏掉，只是结果不能重复，而不是结果里不能有重复的元素，但是b，c就没有这种限制，因为是后面的元素，如果b去重逻辑是判断i和i+1是可以的，因为c数在移动的时候会找到这个结果。不会漏掉。

力扣题目：

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

class Solution {
    // 前两个数循环，后两个数双指针，都要去重，还要注意int类型溢出的问题
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> resultList= new ArrayList<>();
        Arrays.sort (nums);
        int length=nums.length;
        for(int i=0;i<length;i++){
            if(i>0&&nums[i]==nums[i-1]){
                continue;}
            for (int j=i+1;j<length-2;j++){
                if(j>i+1&&nums[j]==nums[j-1]){
                    continue;}
                int left =j+1;
                int right= length-1;
                while (left< right){
                    long sum = (long) nums[i] + nums[j] + nums[left] + nums[right];
                    if (sum == target){
                        List<Integer> temp =new ArrayList<>();
                        temp.add(nums[i]);
                        temp.add(nums[j]);
                        temp.add(nums[left]);
                        temp.add(nums[right]);
                        resultList.add(temp);
                        left++;
                        right--;
                        while (left<length&&nums[left]==nums[left -1]){
                            left++;}
                        while (right>0&&nums[right]==nums[right+ 1]){
                            right--;
                        }
                    }
                    else if(sum<target){
                        left++;}
                    else{
                        right--;}
                }
            }}
        return resultList;
    }
}

本题需要注意的地方：

1. 去重时，第二位数也是需要判断前一位而不是后一位，因为（-1，-1，-1，3）这种数可能漏判，倒数第二位和倒数第一位就不用，和三数之和同理
2. 注意int类型溢出，四个int相加可能超过int类型的限制，因此转化为long类型判断