算法Day5 | Leetcode242.有效的字母异位词、349. 两个数组的交集、202.快乐数、1. 两数之和

242.有效的字母异位词

力扣链接

思路

因为需要判断一个元素的出现次数，所以想到了用哈希法。但是我用的HashMap，这道题比较特殊在仅包含小写字母（还连续），用大小为26的数组维护就可以了。

代码

HashMap

class Solution {
    public boolean isAnagram(String s, String t) {
        HashMap<Character,Integer> map=new HashMap<>(26);
        if(s.length()!=t.length()) return false;
        for(int i=0;i<t.length();i++){
            char c=t.charAt(i);
            if(map.get(c)!=null){
                map.put(c,map.get(c)+1);
            }else{
                map.put(c,1);
            }
        }

        for(int j=0;j<s.length();j++){
            char c=s.charAt(j);
            if(map.get(c)==null || map.get(c)<=0) return false;
            map.put(c,map.get(c)-1);
        }
        return true;
    }
}

数组

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

        for(int j=0;j<s.length();j++){
            directory[s.charAt(j)-'a']--;
        }

        for(int count:directory){
            if(count!=0) return false;
        }

        return true;
    }
}

349. 两个数组的交集

力扣链接

思路

一开始没有看到下面的提示，数组大小和存的数字是有范围的，所以用了Set来维护。跟上一道题一样，有了限制就可以用数组来维护。需要注意的地方就是数组大小不是有提示里的length决定的，还是由存取的数字决定的。

代码

HashSet

Set<Integer> set=new HashSet<>();
        int[] temp=new int[nums1.length>nums2.length?nums1.length:nums2.length];
        for(int i=0;i<nums2.length;i++){
            set.add(nums2[i]);
        }

        int count=0;
        for(int j=0;j<nums1.length;j++){
            if(set.contains(nums1[j])){
                temp[count]=nums1[j];
                count++;
                set.remove(nums1[j]);
            } 
        }

        int[] result=new int[count];
        for(int k=0;k<count;k++){
            result[k]=temp[k];
        }

        return result;
    }

双指针

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        int[] count1=new int[1001];
        int[] count2=new int[1001];
        for(int i=0;i<nums1.length;i++){
            count1[nums1[i]]++;
        }

        for(int j=0;j<nums2.length;j++){
            count2[nums2[j]]++;
        }

        ArrayList<Integer> list=new ArrayList<>();
        for(int k=0;k<1001;k++){
            if(count1[k]!=0 && count2[k]!=0){
                list.add(k);
            }
        }

        int[] result=new int[list.size()];
        int count=0;
        for(Integer i:list){
            result[count]=i;
            count++;
        }

        return result;
    }
}

202.快乐数

力扣链接

思路

题目中加粗标记了会出现无限循环，且n很大就不拿数组维护了，用Set维护，如果出现过，说明循环了不是快乐数，直到出现1

代码

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

    public int getNumber(int n){
        return n*n;
    }
}

1. 两数之和

力扣链接

思路

一开始想的是遍历数组，维护Map，判断是否出现了target减去当前数，有就是有解。但是我想的是HashMap<Integer,ArrayList> 因为我看了示例3出现了同一个数不同下标。但是存的时候很麻烦，回去看题。发现最下面加粗只存在一个有效答案，所以同一个数字最多出现两次（6=3+3）。我在存数字的时候存的是最后一次出现的，我在找答案遍历数组是从前往后遍历，找到的是第一次出现的。所以返回答案的时候不会出现下标冲突。

代码

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