242.有效的字母异位词

题目链接： 203.移除链表元素
文档讲解：代码随想录
状态：so easy

思路：使用计数器数组统计字符串中字符出现频率。

题解

public boolean isAnagram(String s, String t) {
    // 将输入的字符串s转换为字符数组
    char[] sChars = s.toCharArray();
    // 将输入的字符串t转换为字符数组
    char[] tChars = t.toCharArray();
    
    // 初始化一个大小为26的数组，用于计数字符出现的次数
    // 由于只有小写字母，所以数组大小为26，索引0对应字符'a'，索引25对应字符'z'
    int[] counter = new int[26];
    
    // 遍历字符串s的字符数组
    for (char c : sChars) {
        // 将字符转换为0到25的索引，并在对应位置的计数器增加1
        counter[c - 'a']++;
    }
    
    // 遍历字符串t的字符数组
    for (char c : tChars) {
        // 将字符转换为0到25的索引，并在对应位置的计数器减少1
        counter[c - 'a']--;
    }
    
    // 遍历计数器数组，检查是否有任何计数不为0
    for (int i : counter) {
        // 如果任何计数器的值不为0，则说明s和t不是变位词，返回false
        if (i != 0) {
            return false;
        }
    }
    
    // 如果所有计数器的值都为0，则说明s和t是变位词，返回true
    return true;
}

349. 两个数组的交集

题目链接：349. 两个数组的交集
文档讲解：代码随想录
状态：so easy

思路：首先使用一个计数器数组来记录 nums1 中每个元素的出现次数。然后，它检查 nums2 中的每个元素，如果该元素在 nums1 中出现过（即计数器数组中对应的值大于0），则将该元素在计数器数组中的值设置为 -1。之后，它遍历计数器数组，将所有值为 -1 的元素（即两个数组共有的元素）收集到一个 ArrayList 中。最后，将 ArrayList 中的元素复制到一个新的整型数组中，并返回这个数组。

题解：

public int[] intersection(int[] nums1, int[] nums2) {
    // 初始化一个大小为1001的计数器数组，用于存储每个数字的出现次数
    // 数组的大小可以根据实际需要调整，这里假设输入数组中的元素不会超过1000
    int[] counter = new int[1001];

    // 遍历数组nums1，对每个元素在计数器数组中对应的位置增加1
    for (int i : nums1) {
        counter[i]++;
    }
    
    // 遍历数组nums2，检查计数器数组中对应位置的值
    // 如果该位置的值大于0，说明此元素在nums1中出现过，将其设置为-1
    // 这里使用-1来标记nums1和nums2共有的元素
    for (int i : nums2) {
        if (counter[i] > 0) {
            counter[i] = -1;
        }
    }

    // 创建一个ArrayList，用于存储共有元素
    ArrayList<Integer> list = new ArrayList<>();
    
    // 遍历计数器数组，找出所有值为-1的元素，即nums1和nums2共有的元素
    for (int i = 0; i < counter.length; i++) {
        if (counter[i] == -1) {
            list.add(i);
        }
    }
    
    // 创建一个数组，大小为共有元素的个数
    int[] ans = new int[list.size()];
    
    // 初始化一个索引i，用于在ans数组中添加元素
    int i = 0;
    
    // 遍历ArrayList，将共有元素添加到ans数组中
    for (Integer integer : list) {
        ans[i++] = integer;
    }
    
    // 返回包含共有元素的数组
    return ans;
}

202. 快乐数

题目链接：202. 快乐数
文档讲解：代码随想录
状态：so easy

思路：通过使用一个 HashSet 来记录已经遍历过的数字，避免无限循环。如果数字 n 等于1，那么它是一个快乐数。

题解：

public boolean isHappy(int n) {
    // 创建一个HashSet，用于存储已经遍历过的数字
    HashSet<Integer> set = new HashSet<>();
    
    // 使用while循环进行操作，条件是当前数字n不在set中
    while (!set.contains(n)) {
        // 如果n等于1，根据快乐数的定义，返回true
        if (n == 1)
            return true;
        
        // 将当前数字n添加到set中，避免重复遍历
        set.add(n);
        
        // 调用getNum方法，计算n的下一个状态
        n = getNum(n);
    }
    
    // 如果循环结束，说明已经检测到循环，根据快乐数的定义，返回false
    return false;
}

public int getNum(int n) {
    int sum = 0;
    // 使用while循环，直到n变为0
    while (n != 0) {
        // 计算n的最后一位数字的平方，然后加到sum上
        sum += Math.pow(n % 10, 2);
        // 将n除以10并取整，去掉最后一位数字
        n /= 10;
    }
    // 返回计算得到的sum
    return sum;
}

1. 两数之和

题目链接： 1. 两数之和
文档讲解：代码随想录
状态：卡了一会儿，刚开始把所有的元素加入到HashMap中，然后再次遍历数组的时候去HashMap中找是否存在补数，这种方法没有考虑到重复元素的问题

题解：

    public int[] twoSum(int[] nums, int target) {
        // 创建一个HashMap，用于存储遍历过的数字及其索引
        HashMap<Integer, Integer> map = new HashMap<>();

        // 初始化一个长度为2的数组，用于存储两个数的索引
        int[] res = new int[2];

        // 遍历数组nums中的每个元素
        for (int i = 0; i < nums.length; i++) {
            // 检查map中是否存在当前元素的补数
            Integer val = map.get(target - nums[i]);

            // 如果map中存在当前元素的补数（即target - nums[i]）
            if (val != null) {
                // 将补数的索引赋值给res[0]
                res[0] = val;
                // 将当前元素的索引i赋值给res[1]
                res[1] = i;
                // 返回包含两个数索引的数组
                return res;
            }

            // 将当前元素及其索引存入map中
            map.put(nums[i], i);
        }
        
        return res;
    }