哈希表相关题目

有效的字母异位词-简单

//自己写的--感觉写的好复杂，呜呜
class Solution {
    public boolean isAnagram(String s, String t) {
        HashMap<Character,Integer> map=new HashMap<>();
        if(s.length()!=t.length()){
            return false;
        }
        for(int i=0;i<s.length();i++){
            map.put(s.charAt(i),map.getOrDefault(s.charAt(i),0)+1);
            map.put(t.charAt(i),map.getOrDefault(t.charAt(i),0)-1);
        }
        Set entrySet=map.entrySet();
        Iterator iterator=entrySet.iterator();
        while(iterator.hasNext()){
            Map.Entry<Character,Integer> entry=(Map.Entry) iterator.next();
            if(entry.getValue()!=0){
                return false;
            }
        }
        return true;
    }
}

//官方答案
class Solution {
    public boolean isAnagram(String s, String t) {
        if (s.length() != t.length()) {
            return false;
        }
        char[] str1 = s.toCharArray();
        char[] str2 = t.toCharArray();
        Arrays.sort(str1);
        Arrays.sort(str2);
        return Arrays.equals(str1, str2);
    }
}
作者：LeetCode-Solution
链接：https://leetcode.cn/problems/valid-anagram/solution/you-xiao-de-zi-mu-yi-wei-ci-by-leetcode-solution/
来源：力扣（LeetCode）

两个数组的交集-简单

关键是一些函数的用法和stream流的使用。

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        if(nums1==null||nums2==null||nums1.length==0||nums2.length==0){
            return new int[0];
        }
        Set<Integer> r=new HashSet();
        Set<Integer> nums1Tmp=new HashSet();
        for(int i=0;i<nums1.length;i++){
            nums1Tmp.add(nums1[i]);
        }
        for(int j=0;j<nums2.length;j++){
            if(nums1Tmp.contains(nums2[j])){
                r.add(nums2[j]);
            }
        }
        return r.stream().mapToInt(x->x).toArray();

    }
}

快乐数-简单

最开始没有考虑到会循环，还在想为什么这个会用到哈希！

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

两数之和-简单

关于哈希的一些函数使用的考察

class Solution {
    public int[] twoSum(int[] nums, int target) {
        HashMap<Integer,Integer> r=new HashMap<>();
        for(int i=0;i<nums.length;i++){
            if(r.containsKey(target-nums[i])){
                return new int[]{i,r.get(target-nums[i])};
            }
            if(!r.containsKey(nums[i])){
                r.put(nums[i],i);
            }
        }
        return new int[0];
    }
}

四数相加-中等

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        int sum=0;
        Map<Integer,Integer> r=new HashMap<>();
        for(int num1 : nums1){
            for(int num2 : nums2){
                if(r.containsKey(num1+num2)){
                    r.put(num1+num2,r.get(num1+num2)+1);
                }else{
                    r.put(num1+num2,1);
                }
            }
        }
        for(int num3 :nums3){
            for(int num4 :nums4){
                if(r.containsKey(0-num3-num4)){
                    sum+=r.get(0-num3-num4);
                }
            }
        }
        return sum;
    }
}

赎金信-简单

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        HashMap<Character,Integer> r=new HashMap<>();
        HashMap<Character,Integer> m=new HashMap<>();
        for(Character c : ransomNote.toCharArray()){
            r.put(c,r.getOrDefault(c,0)+1);
        }
        for(Character c : magazine.toCharArray()){
            m.put(c,m.getOrDefault(c,0)+1);
        }
        for(Map.Entry<Character,Integer> entry:r.entrySet()){
            Character key=entry.getKey();
            if(m.getOrDefault(key,0)<entry.getValue()){
                return false;
            }
        }
        return true;
    }
}

三数之和-中等

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
       List<List<Integer>> r=new ArrayList<>();
       Arrays.sort(nums);
       for(int i=0;i<nums.length;i++){//最左边的索引
            int left=i+1;
            int right=nums.length-1;
            if(i>0&&nums[i]==nums[i-1]){
                continue;
            }
            while(left<right){
                if((left>i+1)&&nums[left]==nums[left-1]){
                    left++;
                    continue;
                }
                if((right<nums.length-1)&&nums[right]==nums[right+1]){
                    right--;
                    continue;
                }
                if(nums[i]+nums[right]+nums[left]==0){
                    r.add(Arrays.asList(nums[i],nums[right],nums[left]));
                    left++;
                    right--;
                }else if((nums[i]+nums[right]+nums[left])>0){
                    right--;
                }else{
                    left++;
                }
            }

       }
       return r;
    }
}

四数之和-中等

和三数之和是同样的方法。

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