代码随想录-Day06 | LeetCode242.有效的字母异位词、LeetCode349. 两个数组的交集、LeetCode202. 快乐数、LeetCode1. 两数之和

文档讲解: 代码随想录
视频讲解: 《代码随想录》算法公开课-跟着Carl学算法

哈希表简单总结

哈希表适用题目类型：给你一个元素，判断这个元素是否在集合里出现过，首选考虑用哈希表进行快速判断。然后具体分析是用数组、set、还是map：

• 若数值比较小用数组，数值比较大用set
• 还有种情况数值不是很大，但是数值的数字比较分散，用数组比较浪费存储空间，此时用set比较合适
• 当我们不仅要知道元素有没有出现过，还要知道这个元素对应的下标，此时需要使用key和value结构来存放，key来存元素，value来存下标，那么使用map正合适。

LeetCode242.有效的字母异位词

题目链接：242.有效的字母异位词
要求：给定两个字符串，判断其是否为字母异或词（两字符串的字母出现的次数相同，与顺序无关）
思路：仅考虑小写字母（共有26个英文字母），字符a到字符z的ASCII是26个连续的数值，由于数值范围比较小，我们首选考虑数组哈希表，把字符映射到数组也就是哈希表的索引下标，也就是字符a映射为下标0，按顺序递进相应的字符z映射为下标25。掌握好这个思路代码实现就比较容易了。首先动态初始化大小为26的数组作为哈希表，循环遍历字符串s的每个字符，找到每个字符对应的索引位置中元素+1进行记录。对于另一个字符串t同样找到每个字符在数组中对应的索引位置，然后对其元素进行-1操作。一旦两个字符串是字母异或词，我们的数组所有元素应该均为0，否则反之。

class Solution {
    public boolean isAnagram(String s, String t) {
        int[] arr = new int[26]; // 动态初始化大小为26的数组（元素初始化为0）

        // 遍历s字符串映射到数组
        for (int i = 0; i < s.length(); i++) {
            // a对应0索引 z对应25索引
            // 每遍历一个字符 数组对应索引位置+1
            arr[s.charAt(i) - 'a']++;
        }

        // 遍历t字符串同样方式映射到数组
        // 每遍历一个字符 数组对应索引位置-1
        for (int i = 0; i < t.length(); i++) {
            arr[t.charAt(i) - 'a']--;
        }

        // 遍历完成之后数组若都为0 说明两个字符串为字母异位词 否则不是
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] != 0) {
                return false;
            }
        }
        return true;
    }
}

LeetCode349. 两个数组的交集

题目链接：349. 两个数组的交集
题目要求：给定两个数组 nums1 和 nums2 ，返回它们的交集。输出结果中的每个元素一定是唯一的。我们可以不考虑输出结果的顺序。

利用set求解

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        // 哈希表适用题目类型：给你一个元素，判断这个元素是否在集合里出现过。首选考虑用哈希表。
        // 然后具体分析是用数组、set、还是map
        // 若数值比较小用数组，数值比较大用set
        // 还有种情况数值不是很大，但是数值的数字比较分散，用数组比较浪费存储空间 用set比较合适

        // 创建两个set: 一个存nums1，一个存结果
        Set<Integer> set = new HashSet<>(); // 和集合的创建方式一样
        Set<Integer> res = new HashSet<>();

        // 将nums1存在hash表中
        for (int i : nums1) {
            set.add(i);
        }

        // 遍历nums2内的元素 判断hash表中是否有该元素
        // 若有该元素 则将此元素放到res中 帮我们做去重操作
        for (int i : nums2) {
            if (set.contains(i)) {
                res.add(i);
            }
        }

        // 函数返回值是数组类型 进一步转换成数组
        int[] arr = new int[res.size()]; // 动态初始化数组 大小为res大小
        int count = 0;
        for (int i : res) {
            arr[count++] = i;
        }
        return arr;
    }
}

利用数组求解（数组个数小于1000）

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        // 题目表示形参数组的个数小于1000 可以利用数组来求解
        // 动态初始化数组
        int[] arr = new int[1001]; // 作为nums1的Hash表

        // 创建个set用于存结果 让其帮我们自动去重
        Set<Integer> res = new HashSet<>();
        for (int i : nums1) {
            // 遍历nums1元素 然后在对应映射的索引位置置1 取交集这里不能+1
            arr[i] = 1;
        }

        // 遍历nums2 查找对应映射的索引位置是否为1 若为1说明为交集 将其值存到res中
        for (int i : nums2) {
            if (arr[i] == 1) {
                res.add(i);
            }
        }

        // 将res转换成数组然后进行返回
        int[] resArr = new int[res.size()];
        int count = 0;
        for (int i : res) {
            resArr[count++] = i;
        }
        return resArr;
    }
}

LeetCode202. 快乐数

题目链接：202. 快乐数

class Solution {
    public boolean isHappy(int n) {
        // sum 重复出现之后说明不是快乐数
        // 判断一个数是否出现在集合里就要考虑哈希表
        Set<Integer> sumSet = new HashSet<>(); // 创建存放sum的哈希表
        int num = 0, sum = 0;
        boolean flag = true;
        while (flag) {
            while (n != 0) {
                num = n % 10; // 个位数
                n = n / 10; // 每次循环去除当前数字的个位
                sum += num * num; // 计算当前数字的平方
            }
            if (sum != 1 && sumSet.contains(sum)) {
                flag = false; // sum不为1且在sumSet中出现
            } else if (sum == 1) {
                return true;
            }
            sumSet.add(sum); // 遍历完将sum放到哈希表
            n = sum; // 更新n
            sum = 0; // 每次循环开始sum=0
        }
        return false;
    }
}

LeetCode1. 两数之和

题目链接：1. 两数之和

	class Solution {
        public int[] twoSum(int[] nums, int target) {
            // 创建map：key存放元素 value存放下标
            Map<Integer, Integer> map = new HashMap<>();
            int[] res = new int[2]; // 动态初始化结果数组
            //遍历数组
            for (int i = 0; i < nums.length; i++) {
                // 寻找目标元素 满足两数相加为target
                int temp = target - nums[i];
                // 目标元素是否在map中存在
                if (!map.containsKey(temp)) {
                    map.put(nums[i], i);
                } else {
                    // 返回查询的value和当前下标
                    res = new int[]{map.get(temp), i};
                    return res;
                }
            }
            return res;
        }
    }