代码随想录Day6-哈希表01 242.有效的字母异位词 349. 两个数组的交集 202. 快乐数 1. 两数之和

242. 有效的字母异位词

        这题直接用字符串判断了。。哈希感觉多余了是不？？？？？？

class Solution {
    public boolean isAnagram(String s, String t) {
        char[] s1 = s.toCharArray();//s变成字符数组
        Arrays.sort(s1);//字符数组排序
        String s2 = String.valueOf(s1);//数组转成字符串
        char[] t1 = t.toCharArray();//t同理
        Arrays.sort(t1);
        String t2 = String.valueOf(t1);
        return s2.equals(t2);//equals方法判断相等
    }
}

        如果首先判断两字符串长度是否相等可以节省部分时间（长度都不相等了后面也不用判断了），且最后也没必要数组转字符串，直接Arrays.equals(s1, t1);判断数组是否相等就好。

349. 两个数组的交集

        这个想法有点复杂而且效率是真低

        执行用时：5 ms, 在所有 Java 提交中击败了13.05%的用户

        5555555

        先对两个数组进行排序，排好序后用双指针遍历两数组，找到相同的数放到HashSet中，可以起到添加的同时去除重复元素的效果，最后再用stream流把HashSet转成数组返回。

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        int i = 0, j = 0;
        //排序
        Arrays.sort(nums1);
        Arrays.sort(nums2);
        //两数组中相同的元素放到h中，同时去重
        HashSet<Integer> h = new HashSet<>();
        while(i < nums1.length && j < nums2.length){
            if(nums1[i] == nums2[j]){
                h.add(nums1[i]);
                i++;
                j++;
            }else if(nums1[i] < nums2[j]){
                i++;
            }else{
                j++;
            }
        }
        //把HashSet转成数组
        return h.stream().mapToInt(x -> x).toArray();
    }
}

        官解：没用HashSet，直接创建一个数组，每次判断加进数组的数跟前一个相不相等就可以实现去重了，因为数组长度不可控，使用index变量记录数组存了多少数进去，最后再截取数组的0~index就好啦。

        👇借鉴了大佬的哈希做法，很妙哇，把nums1先全部加进set1里，再把nums2中set1包含的元素加进set2中，妙蛙妙蛙！

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        Set<Integer> set1 = new HashSet<>();
        Set<Integer> set2 = new HashSet<>();      
        for(int i:nums1){
            set1.add(i);
        }
        for(int i:nums2){
            if(set1.contains(i)){
                set2.add(i);
            }
        }
        return set2.stream().mapToInt(x -> x).toArray();
    }
}

202. 快乐数

        一开始一点也不快乐，后来写出来了：happy happy happy

        一开始写不出来的原因是脑子被囚禁了，想要用递归和哈希表，但是因为这个isHappy函数返回的是布尔类型，一时间不知道怎么用，而且如果递归的话肯定不能在递归函数里面用哈希表存数据。后来才想到可以自己写一个新的函数然后用while循环解决😂，笨笨捏

        思路：首先创建一个happy函数，计算每一次的平方和。在isHappy函数中，使用哈希表判断平方和是否出现过，把添加happy结果（平方和）到哈希表中当作循环条件，如果happy结果没有出现过，则成功添加到哈希表中，如果出现过，添加失败，循环条件不成立，直接退出循环，也就能判断它不是快乐数（原因是如果一个数第二次出现，再做相同的产生平方数操作，会陷入死循环）。

        循环内，将happy结果重新赋值给他自己，保证能够循环产生新的happy结果，如果这个结果等于1，说明找到快乐数。

class Solution {
    public boolean isHappy(int n) {
        HashSet<Integer> h = new HashSet<>();
        while(h.add(happy(n))){
            n = happy(n);
            if(n == 1){
                return true;
            }
        }
        return false;
    }
    //happy函数用来得到每一个平方和
    public int happy(int n){
        int sum = 0;
        while(n != 0){
            int temp = n % 10;
            sum += temp * temp;
            n /= 10;
        }
        return sum;
    }
}

        官解还有快慢指针和数学方法！好聪明，有空来看~

1. 两数之和

        暴力解法，不暴力不会啊嘤嘤嘤

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

        官解！我的神

        创建HashMap保存数和数的下标，遍历数组，在HashMap中找另一个数（target - nums[i]），找到直接返回，找不到就把当前 nums[i], i 放到表中

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

        下次一定要自己写出来这个解法qwq👆