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

我觉得这一章最重要的一句话：若要判断某个元素有没有出现过，用哈希表的思想

有范围可以用数组，没范围用set啥的

主要是复习Java的字符串操作以及各种小技巧

242. 有效的字母异位词

思路就看卡哥，代码如下

    public boolean isAnagram(String s, String t) {
        int[] res = new int[26];

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

        for (int i = 0; i < t.length(); i++) {
            res[t.charAt(i) - 'a']--;
        }

        for (int i = 0; i < res.length; i++) {
            if (res[i] != 0) return false;
        }
        return true;
    }

我觉得有几个小技巧值得注意：

1. 比较两个哈希数组是否相同，用的是先+后-看看最终结果是不是0
2. s.charAt(i) - 'a'这个拿到字母的相对位置我觉得也也挺有意思

349. 两个数组的交集

思考…好像没啥思路可写

这道题主要就是熟悉了一下Set的操作

    public int[] intersection(int[] nums1, int[] nums2) {
        // 如果直接是null
        if (nums1 == null || nums2 == null) return null;
        // 如果有哪个是空数组
        if (nums1.length == 0 || nums2.length == 0) return new int[0];

        HashSet<Integer> set1 = new HashSet<>();
        HashSet<Integer> ansSet = new HashSet<>();

        // 遍历nums1，确定这个数组里面有什么元素
        for (int i = 0; i < nums1.length; i++) {
            set1.add(nums1[i]);
        }

        // 遍历nums2，每遍历一个就问set1是否包含这个元素，如果包含，则要放到交集ansSet里面
        for (int i = 0; i < nums2.length; i++) {
            if (set1.contains(nums2[i])) {
                ansSet.add(nums2[i]);
            }
        }

        // 将ansSet转换为数组进行返回
        // 使用流将 HashSet 转换为 int 数组
        int[] ansArray = ansSet.stream().mapToInt(Integer::intValue).toArray();

        return ansArray;
    }

202. 快乐数

我觉得这道题思路上没啥难，主要是要注意各位平方求和

    public boolean isHappy(int n) {
        HashSet<Integer> ansSet = new HashSet<>();

        while (n != 1) {
            ansSet.add(n);
            n = getSum(n);
            if (ansSet.contains(n)) return false;
        }
        return true;
    }

    // 获取每位数字的平方和
    public static int getSum (int n) {
        int sum = 0;
        while (n != 0) {
            // temp是n的最后一位数
            int temp = n % 10;
            sum += temp * temp;
            // n扔掉最后一位
            n /= 10;
        }

        return sum;
    }

1. 两数之和

这个题有几个限制，从而降低难度：

1. 明确告诉你“两个整数”
2. 每种输入只会对应一个答案

由此思路就是：遍历这个数组，每拿到一个数，就问还需要几才能加起来等于目标数，这个数之前出现过吗？

如果去掉这些限制，好像要用回溯

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