代码随想录第六天：242.有效的字母异位词、​349：两个数组的交集​、​202：快乐数​、​1：两数之和​

242：有效的字母异位词

另外开辟一个长度为字母表个数的数组count，用来记录各个字母出现的次数，对数组1进行遍历，在count找到当前遍历元素num1[i]的位置，记录其次数。对数组2进行遍历的时候，则在count数组中将其次数减1。最后看count数组中有无非零元素，如果有，说明不互为字母异位词。

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

349：两个数组的交集

把一个数组的每个元素依次添加到哈希表res1中，然后对另一个数组进行遍历，如果第二个数组中的元素已经存在哈希表中了，则把该元素添加到resSet中。最后，把resNet中的元素存储到数组中并返回。

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        int count = 0;
        int size1 = nums1.length, size2 = nums2.length;
        if((nums1==null)||(nums2==null))
            return null;
        HashSet<Integer> set1 = new HashSet<>();
        HashSet<Integer> resSet = new HashSet<>();
        for(int i=0;i<size1;i++){
            set1.add(nums1[i]);
        }
        for(int i=0;i<size2;i++){
            if(set1.contains(nums2[i])){
                resSet.add(nums2[i]);
            }
        }

        int[] res = new int[resSet.size()];
        int k = 0;
        Iterator itr = resSet.iterator();
        while(itr.hasNext()){
            res[k++] = (int)itr.next();
        }

        return res;
    }
}

这里哈希表转为数组是通过遍历哈希表元素，再依次传入数组，也可以采用流的方法。

202：快乐数

最开始不觉得要用哈希表，然后发现要是在循环中一直为1，或者说一直循环，比如说一直从abcd->efgh->....->abcd这种。这个时候利用哈希表就可以很快的判断处于循环中，无论循环多少次都不可能到1，就不是快乐数。

class Solution {
    public boolean isHappy(int n) {
        HashSet<Integer> set = new HashSet<>();
        int sum = getSquare(n);
        while(sum!=1){
            if(set.contains(sum)){
                return false;
            }
            set.add(sum);
            sum = getSquare(sum);
        }
        return true;
    }
    int getSquare(int n){
        String s = String.valueOf(n);
        int len = s.length();
        int sum = 0;
        for(int i=0;i<len;i++){
            sum +=  (s.charAt(i)-'0')*(s.charAt(i)-'0');
        }
        return sum;
        }
}

1：两数之和

最开始想到的就是暴力解，时间复杂度为O（n）

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int len = nums.length;
        int[] res = new int[2];
        for(int i=0;i<len;i++){
            for(int j=i+1;j<len;j++){
                if((nums[i]+nums[j])==target){
                    res[0] = i;
                    res[1] = j;
                }
            }
        }
        return res;
    }
}

考虑将数组的<元素，下标>依次放入HashMap中，之后再遍历数组，如果target减去数组当前遍历值所得的结果在HashMap中存在，需要检查一下找到的这个key对应的value是否和和当前数组下标一致，以满足“数组中同一个元素在答案里不能重复出现”的要求。如果二者不一致的话，那么返回对应的下标即可。

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

总结：考虑使用哈希法的情景：当我们需要查询一个元素是否出现过，或者一个元素是否在集合里的时候，就要第一时间想到哈希法。

这两天太忙了，没能及时跟上刷题，希望后面可以追上进度。