???? 解题思路

1. ???? 确定输入与输出
2. ???? 分析复杂度
3. ???? 复杂题目拆分 ：严谨且完整 地拆分为更小的子问题（哈希表的使用场景）–（多总结）
4. ???? 选择处理逻辑： 根据拆分后的子问题，总结并选择合适的问题处理思路
5. ???? 检查特殊情况：边界条件和特殊情况
6. ???? 返回结果

---

● 242.有效的字母异位词 （做统计）

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

● 349. 两个数组的交集 （Set 去重）

class Solution {
    public static int[] intersection(int[] nums1, int[] nums2)
    {
        if (nums1.length == 0 || nums2.length == 0) {
            return new int[0];
        }
        int len1 = nums1.length, len2 = nums2.length;
        Set<Integer> set = new HashSet<>(); // 确保不重复
        for (int num : nums1) {
            set.add(num);
        }
        List<Integer> res = new ArrayList<>(); // 动态数组记录结果
        for (int num : nums2) {
            if (set.contains(num)) {
                res.add(num);
                set.remove(num);
            }
        }
        int[] result = new int[res.size()];
        for (int i = 0; i < res.size(); i++) {
            result[i] = res.get(i);
        }
        return result;
    }
}

● 202. 快乐数（快慢指针的实际应用（变体））

class Solution {
    public boolean isHappy(int n) {
        if (n == 1 || getNext(n) == 1) return true;
        int slow = n;
        int fast = getNext(n);
        while (fast != 1 && slow != fast) {
            slow = getNext(slow);
            fast = getNext(getNext(fast));
        }
        return fast == 1;
    }

    private int getNext(int n) {
        int totalSum = 0;
        while (n > 0) {
            int d = n % 10;
            n = n / 10;
            totalSum += d * d;
        }
        return totalSum;
    }
}

● 1. 两数之和 （哈希表降低时间复杂度）

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