【代码随想录】哈希表

242.有效的字母异位词

class Solution {
    public boolean isAnagram(String s, String t) {
        if(s==null || t==null || s.length()!=t.length()){
            return false;
        }
        Map<Character, Integer> mapS=strToMap(s);
        Map<Character, Integer> mapT=strToMap(t);
        return mapS.equals(mapT);
    }
    private Map<Character, Integer> strToMap(String str){
        Map<Character, Integer> map = new HashMap<>();
        for(int i=0;i<str.length();i++){
            char ch=str.charAt(i);
            // if(map.containsKey(ch)){
            //     map.put(ch,map.get(ch)+1);
            // }else{
            //     map.put(ch,1);
            // }
            map.put(ch, map.getOrDefault(ch,0)+1);
        }
        return map;
    }
}

为什么用下面的代码代替 equals() 方法来判断两个 Map 的内容是否相等时，会有一个测试用例不通过？

for(Map.Entry<Character, Integer> entry:mapS.entrySet()){
    Character keyS=entry.getKey();
    Integer valueS=entry.getValue();
    if(!mapT.containsKey(keyS) || mapT.get(keyS)!=valueS){
        return false;
    }
}

349. 两个数组的交集

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        if(nums1==null || nums2==null){
            return null;
        }
        // 分别将两个数组转成Set集合，去重
        Set<Integer> set1=new HashSet<>();
        for(int i=0;i<nums1.length;i++){
            set1.add(nums1[i]);
        }
        Set<Integer> set2=new HashSet<>();
        for(int i=0;i<nums2.length;i++){
            set2.add(nums2[i]);
        }
		//求set1与set2的交集，交集保存在set1中
		//retainAll：保留两者都有的
        set1.retainAll(set2);
        int[] num=new int[set1.size()];
        int j=0;
        for(Integer item:set1){
            num[j++]=item;
        }
        return num;
    }
}

202. 快乐数

class Solution {
    public boolean isHappy(int n) {
        // 将正整数n的每一位放入List集合，升序排列
        List<Integer> list = getNewList(n);

        Set<List> set=new HashSet<>();
        int sum=-1;
        while(true){
            if(set.contains(list)){
                return false;
            }
            sum=listSum(list);
            if(sum==1){
                return true;
            }
            else{
                set.add(list);
                list=getNewList(sum);
            }
        }
    }
    private List<Integer> getNewList(int num){
        List<Integer> list = new ArrayList<>();
        while(num/10!=0){
            int modRes=num%10;
            list.add(modRes);
            num/=10;
        }
        list.add(num); 
        Collections.sort(list);
        return list;
    }
    private int listSum(List<Integer> list){
        int sum=0;
        for (Integer item : list) {
            sum+=item*item;
        }
        return sum;
    }
}

1. 两数之和

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer,Integer> map=new HashMap<>();
        for(int i=0;i<nums.length;i++){
            // 要在数组元素还未进Map集合时判断Map中是否有target-nums[i])
            if(map.containsKey(target-nums[i])){
                return new int[]{map.get(target-nums[i]), i};
            }
            //Map中，key是数组元素值，value是元素在数组中的下标
            map.put(nums[i],i);
        }
        return null;
    }
}

454. 四数相加 II

思路：将四个数组分为两组处理。

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

383. 赎金信

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        // 将magazine中的字符以及对应出现的频率记录到Map中
        Map<Character,Integer> map=new HashMap<>();
        for(int i=0;i<magazine.length();i++){
            map.put(magazine.charAt(i),map.getOrDefault(magazine.charAt(i),0)+1);
        } 
        for(int i=0;i<ransomNote.length();i++){
            char currentCh = ransomNote.charAt(i);
            if(!map.containsKey(currentCh)){
                return false;
            }else{
                map.put(currentCh,map.get(currentCh)-1);
                if(map.get(currentCh)==0){
                    map.remove(currentCh);
                }
            }
        }
        return true;
    }
}

15. 三数之和

用了哈希表，时间超限，据说用排序+双指针思路简单且可行，后面刷到双指针的题再完成这个方法的题解。

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        // key：两个元素的和    value：所有和等于key的元素组合，以下标的形式记录
        Map<Integer, List<List<Integer>>> map = new HashMap<>();
        for(int i=0;i<nums.length;i++){
            for(int j=i+1;j<nums.length;j++){
                // 将前两个元素包装到List中
                List<Integer> innerList=new ArrayList<>();
                innerList.add(i);
                innerList.add(j);

                int key=nums[i]+nums[j];
                if(!map.containsKey(key)){
                    List<List<Integer>> outerList=new ArrayList<>();                
                    outerList.add(innerList);
                    map.put(key, outerList);
                }else{
                    map.get(key).add(innerList);
                }
            }
        }
        Set<List<Integer>> resSet=new HashSet<>();  
        for(int k=0;k<nums.length;k++){
            if(map.containsKey(-nums[k])){
                List<List<Integer>> outerList=map.get(-nums[k]);
                for(List<Integer> innerList : outerList){
                    if(!innerList.contains(k)){
                        List<Integer> innerResList=new ArrayList<>();
                        innerResList.add(nums[innerList.get(0)]);
                        innerResList.add(nums[innerList.get(1)]);
                        innerResList.add(nums[k]);
                        Collections.sort(innerResList);
                        resSet.add(innerResList);
                    }
                }
            }
        }
        return new ArrayList<>(resSet);
    }
}

18. 四数之和

跟三数之和一样，也是排序+双指针，刷到双指针再做。