代码随想录 哈希表

题目概览

1.有效的字母异位词力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

2.两个数组的交集力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

3.快乐数 力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

4.两数之和力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

5.四数相加2力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

6. 赎金信力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

7.三数之和力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

8. 四数之和力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

哈希表常用的数据结构：数组，HashMap，Set

有效的字母异位词

当题目中涉及字符，只包含全小写或者全大写情况，通常采用数组存储，将26个字母映射到数组内。数组常用于已知映射范围的大小。

为了减少空间的浪费，遍历第一个字符串的时候将字符出现的次数记录在数组中，遍历第二个字符串的时候减去字符出现的次数。最后遍历一遍数组，如果数组中有不为0的情况，即返回false。

class Solution {
    public boolean isAnagram(String s, String t) {
       int[] hash=new int[26];
       for(int i=0;i<s.length();i++){
           hash[s.charAt(i)-'a']++;
       }
       for(int i=0;i<t.length();i++){
           hash[t.charAt(i)-'a']--;
       }
       for(int i=0;i<26;i++){
           if(hash[i]!=0)
           return false;
       }
       return true;
       
    }
}

时间复杂度：O(n)

空间复杂度：O(1)

两个数组的交集

根据样例可以看到输出的结果去重，可以联想到使用Set。

遍历第一个数组，将去重后的所有值存储进Set。再遍历第二个数组，判断当前遍历的元素是否在Set内，如果存在加入结果集。

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        int[] hash1=new int[1002];
        int[] hash2=new int[1002];
        for(int i=0;i<nums1.length;i++){
            hash1[nums1[i]]++;
        }
        for(int i=0;i<nums2.length;i++){
            hash2[nums2[i]]++;
        }
        ArrayList<Integer> list=new ArrayList<>();
        for(int i=0;i<1002;i++){
            if(hash1[i]>0&&hash2[i]>0){
                list.add(i);
            }
        }
        int[] res=new int[list.size()];
        for(int i=0;i<list.size();i++)
        res[i]=list.get(i);
        return res;

    }
}

时间负责度：O(mn)

空间复杂度：O(n)

快乐数

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

如果 n 是快乐数就返回 True ；不是，则返回 False 。

重复替换每个位置上数字的平方和的过程需要不断重复，如何判断是否是无限重复呢？

将每一次求出的和sum存储进Set，如果sum重复出现贼说明是死循环，始终变不到1。返回false；

class Solution {
    public boolean isHappy(int n) {
     Set<Integer> res=new HashSet<>();
     while(n!=1&&!res.contains(n)){
         res.add(n);
         n=getNextNumber(n);
     }
     return n==1;
    }
    public int getNextNumber(int n){
        int sum=0;
        while(n>0){
            int temp=n%10;
            sum+=temp*temp;
            n=n/10;
        }
        return sum;
    }
}

时间复杂度：O(logn)

空间复杂度：O(logn)

两数之和

Hashmap入门使用

将数组的值和数组下标的映射存储进Hashmap内，遍历一遍数组，将已出现的值存储进Hashmap，在Hashmap里寻找target-nums[i]，如果存在，返回下标即可。

class Solution {
    public int[] twoSum(int[] nums, int target) {
       int[] res=new int[2];
       Map<Integer,Integer> map=new HashMap<>();
       if(nums==null||nums.length==0)
       return null;
       for(int i=0;i<nums.length;i++){
           int temp=target-nums[i];
           if(map.containsKey(temp)){
               res[0]=i;
               res[1]=map.get(temp);
               break;
           }
           map.put(nums[i],i);
       }
       return res;
    }
}

时间复杂度：O(n)

空间复杂度：O(n)

四数相加

给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 (i, j, k, l) ，使得 A[i] + B[j] + C[k] + D[l] = 0。

首先想到的是暴力枚举，四个数组遍历时间复杂度就是O(n^4)，如何进行优化呢？先遍历两个数组，将所有可能的组合的和存储进Hashmap的key，同时value存储和出现的次数。再遍历剩下两个数组，遍历的过程中寻找是否有和为0的组合，如果有返回和出现的次数。

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

时间复杂度：O(n^2)

空间复杂度：O(n^2)

赎金信

两个小写字符串——数组存储

判断第一个字符串 ransom 能不能由第二个字符串 magazines 里面的字符构成

定义一个数组用来存储字符出现的次数，第一次遍历++，第二次遍历--

本题关键：字符串谁先遍历

由哪个字符串构成就先遍历哪个字符串

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        if(ransomNote.length()>magazine.length()) return false;
        int[] hash=new int[26];
        for(int i=0;i<magazine.length();i++){
            hash[magazine.charAt(i)-'a']++;
        }
        for(int i=0;i<ransomNote.length();i++){
            hash[ransomNote.charAt(i)-'a']--;
        }
        for(int i=0;i<26;i++){
            if(hash[i]<0) return false;
        }
        return true;
    }
}

时间复杂度：O(n)

空间复杂度：O(1)

三数之和

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

哈希法可以实现，但是要去除不重复的三元组较为困难，本题采用双指针算法。

首先对数组进行排序（从小到大）

数组遍历到第i个元素，左指针left为i+1,右指针为nums.length-1，记录三数之和sum

sum=nums[i]+nums[left]+nums[right]

对sum进行判断，如果sum大于0，说明sum太大，right减小

如果sum小于0，说明sum太小，left增大

如果sum等于0，加入结果集。

sum判断的出口为left和right相遇。

去重处理：

由于已经排好序，只需要和相邻元素进行对比。

i去重：如果 i>0并且nums[i]==nums[i-1] 跳过该元素

left去重：向right方向去重 nums[left]==nums[left+1]

right去重：向left方向去重 nums[right]==nums[right--]

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> res=new ArrayList<>();
        Arrays.sort(nums);
        for(int i=0;i<nums.length;i++){
            if(nums[i]>0) return res;
            if(i>0&&nums[i]==nums[i-1]) continue;
            int left=i+1;
            int right=nums.length-1;
            while(left<right){
                int sum=nums[i]+nums[left]+nums[right];
                if(sum>0) right--;
                else if(sum<0) left++;
                else{
                    res.add(Arrays.asList(nums[i],nums[j],nums[left],nums[right]));
                    while(left<right&&nums[left]==nums[left+1]) left++;
                    while(left<right&&nums[right]==nums[right-1]) right--;
                    left++;
                    right--;
                }
            }
        }
        return res;
    }
}

时间复杂度：O(n^2)

空间复杂度：O(1)

四数之和

给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。

和三数之和相似

不过加入了新的变量下标 j

额外对 j 进行去重：j>i+1&&nums[j]==nums[j+1]

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
         List<List<Integer>> res=new ArrayList<>();
         Arrays.sort(nums);
         for(int i=0;i<nums.length;i++){
            if(nums[i]>0&&nums[i]>target) return res;
            if(i>0&&nums[i-1]==nums[i]) continue;
            for(int j=i+1;j<nums.length;j++){
                if(j>i+1&&nums[j]==nums[j-1]) continue;
                int left=j+1;
                int right=nums.length-1;
                while(left<right){
                   long sum=(long)nums[i]+nums[j]+nums[left]+nums[right];
                   if(sum>target) right--;
                   else if(sum<target) left++;
                   else{
                     res.add(Arrays.asList(nums[i],nums[j],nums[left],nums[right]));
                     while(left<right&&nums[left]==nums[left+1]) left++;
                     while(left<right&&nums[right]==nums[right-1]) right--;
                     left++;
                     right--;
                   }
                   
                }
            }
            
         }
         return res;
    }
}

时间复杂度：O(n^3)

空间复杂度：O(1)

总结

判断一个元素是否出现集合里的时候，就要考虑哈希法

常用的数据结构：数组，Set和Hashmap

数组：常用于有限长度的集合，种类有限，例如小写字母，大写字母，将其映射到数组内，数组内可以存储字符出现的次数

Set：特点是不含重复元素，当需要对数组去重处理时，则可以使用

Hashmap：建立一种映射，映射双方可以自己定义，可以是数字出现的次数，调用对应的方法，常用于结果集合长度不确定的情况 去重不方便