哈希表（上 代码随想录二刷总结）

哈希表（上）

1.有效的字母异位词

leetcode 242

class Solution {
    public boolean isAnagram(String s, String t) {
        int[] hash = new int[26]; 
        //字符串s放入hash中
        for(int i=0;i<s.length();i++){
            hash[s.charAt(i)-'a']++;
        }
        //hash减去字符串t出现的字符
        for(int i=0;i<t.length();i++){
            hash[t.charAt(i)-'a']--;
        }
        //判断是否完全覆盖
        for(int i=0;i<hash.length;i++){
            if(hash[i]!=0){
                return false;
            }
        }
        return true;
    }
}

哈希表中最基础的题之一，就是把字符串的每个字符存在哈希表中（此处以数组代替），判断另一个字符串中出行的字符数是否与其相等。

2.两个数组的交集

leetcode 349

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        HashSet<Integer> hs = new HashSet<>();
        for(int i:nums1){
            hs.add(i);
        }
        HashSet<Integer> hs_res = new HashSet<>();
        for(int i:nums2){
            if(hs.contains(i)){
                hs_res.add(i);
            }
        }
        int[] res = new int[hs_res.size()];
        int j=0;
        for(int i:hs_res){
            res[j++] = i;
        }
        return res;
    }
}

哈希表中最基础的题之一

3.快乐数

leetcode 202

class Solution {
    public boolean isHappy(int n) {
        HashSet<Integer> hs = new HashSet<>();
        int tem_sum = get_sum(n);
        while(true){
            if(hs.contains(tem_sum)){
                return false;
            }else if(tem_sum==1){
                return true;
            }else{
                hs.add(tem_sum);
                tem_sum = get_sum(tem_sum);
            }
        }
    }
    public int get_sum(int n){
        int sum=0;
        while(n!=0){
            sum += (n%10) * (n%10);
            n = n/10;
        }
        return sum;
    }
}

这个题最重要的是不要忽略循环的情况，即这个数求和过程中又得到了这个数。出了上面hash的算法，官方还提供了一种快慢指针的算法。

一直去求下一位数的结果有三种：
1. 得到1
2. 陷入循环
3. 数值无限大（这一种其实不存在）
上述表格展示了当前位数最大数值以及下一位数，如1位数时，最大的是9，下一位数就是99=81。所以1位数的时候，只会在81以下循环或者等于1，不会出行无限大的情况，其他多位数情况类似。即在Digits=k<=Largest的范围，其各位求和平方的范围为NextNext。

class Solution {
    private int getNext(int n) {
        int totalSum = 0;
        while (n > 0) {
            int d = n % 10;
            n = n / 10;
            totalSum += d * d;
        }
        return totalSum;
    }
    public boolean isHappy(int n) {
        // 检查链表有环的方法 快慢指针法
        int slow = n;
        int fast = getNext(n);

        while(true){
            if(fast==1){
                return true;
            }else if(slow==fast){
                return false;
            }else{
                slow = getNext(slow);
                fast = getNext(getNext(fast));
            }
        }
    }
}

快慢指针的方法，我们是以链表找环的方式来判断，fast每次跳两个节点，slow跳一个，这样去判断，详情见链表篇 环形链表Ⅱ。

4.四数相加Ⅱ

leetcode 454

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

遍历nums1和nums2的组合，将其和的差（key）放入hashmap中，value为其和出现的次数。再遍历nums1和nums2的组合，若hashmap中存在一个组合，则将value的值（出行的次数）加到结果中去，这里需要注意的是数组的序列有顺序，不是说你nums3[1]+nums4[4]==2出行在了hashmap中，你将次数累加到了结果中，后面就不考虑key=2这个情况。因为遍历的组合每一次都是不同的，万一后面出现nums[3]++nums4[2]==2，也要累加key=2出行的次数。