Leetcode-day05-哈希表

数组（数组下标做映射），Set，Map。

一般来说如果哈希表大小确定，而且比较小，可以优先用数组，因为它比较快。

242. 有效的字母异位词

其实就是判断都是两个字符串是不是都有相同的字母组成，顺序可以不一致。

利用Arrays的方法

两字符串先排序后比较

    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);
    }

用数组

因为只有小写字母，所以可以用数组来做，每个数组位置代表对应字母的出现次数，遍历第一个数组统计每个字母的出现次数放入数组，遍历第二个数组把对应字母出现的次数--。

最后的数组中如果全是0，那就是符合题意。

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

        for(int i=0;i<26;i++){
            if(hashArr[i]!=0){
                return false;
            }
        }
        return true;
    }

用HashMap

遍历第一个字符串把字符和出现次数放入HashMap。

遍历第二个字符串把字符和出现次数--放入HashMap。

这样如果该字符对于的次数<0，两字符串就无效，返回false

    public boolean isAnagram(String s, String t) {
        if(s.length()!=t.length()){
            return false;
        }
        HashMap<Character,Integer> hashmap = new HashMap<>();
        for(int i = 0;i<s.length();i++){
            char ch = s.charAt(i);
            hashmap.put(ch,hashmap.getOrDefault(ch,0)+1);
        }
        for(int i = 0;i<t.length();i++){
            char ch = t.charAt(i);
            hashmap.put(ch,hashmap.getOrDefault(ch,0)-1);
            if(hashmap.get(ch)<0){
                return false;
            }
        }
        return true;
    }

349. 两个数组的交集

输出结果每个元素唯一，不分先后，所以可以用hashMap，把第一个数组的元素全部放到hashmap1里面，遍历第二个数组的元素如果hashmap1里面已经有了，就把他放到hashmap里（会自动去重），最后把hashmap转成数组返回

    public int[] intersection(int[] nums1, int[] nums2) {
        HashSet<Integer> hashSet1 = new HashSet<>();

        HashSet<Integer> hashSet = new HashSet<>();
        for(int i = 0;i<nums1.length;i++){
            hashSet.add(nums1[i]);
        }
        for(int i = 0;i<nums2.length;i++){
            if(hashSet.contains(nums2[i])){
                hashSet1.add(nums2[i]);
            }
        }
        int index = 0;
        int[] res = new int[hashSet1.size()];
        for (Integer num : hashSet1) {
            res[index++] = num;
        }
        return res;

    }

202. 快乐数

结果不是1而且没有循环（该结果已经存在于hashset），就接着计算。否则跳出，如果是因为结果为1跳出就是开心数，如果不是1就不是开心数。

注意判断条件：刚开始写错了 n!=1 || !hashset.contains(n)      这样如果n!=1 就短路了，不管后面有没有循环，都在一直while，造成死循环

    public boolean isHappy(int n) {
        HashSet<Integer> hashset = new HashSet<>();
        while(n!=1&&!hashset.contains(n)){
            hashset.add(n);
            n = getRes(n);
        }
        return n==1;
    }
    int getRes(int n){
        int res=0;
        int x;
        while(n>0){
            x = n%10;
            res = res + x*x;
            n = n/10;
        }
        return res;
    }

1. 两数之和

思路很简单，就是看hashMap中有没有要找的元素，有就把他俩的下标返回。

需要注意的是：new int[0]; 是在Java中创建了一个长度为0的整型数组。这个语句的含义是返回一个新的空整型数组。虽然数组已经被分配了内存空间，但由于其长度为0，所以它不包含任何元素。

new int[]{0}; 是在Java中创建了一个包含单个元素的整型数组。这个语句的含义是返回一个新的整型数组，该数组包含一个元素，值为 0。数组的长度为1，唯一的元素是 0。

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

    }