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

---

一、242. 有效的字母异位词

题目描述： 给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
注：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。

1. 排序

t和s是异位词等价于「两个字符串排序后相等」。

• 时间复杂度：$O(nlogn)$
• 空间复杂度：$O(logn)$

class Solution {
    public boolean isAnagram(String s, String t) {
        if (s.length() != t.length()) {
            return false;
        }
        char[] str1 = s.toCharArray();
        char[] str2 = t.toCharArray();
        Arrays.sort(str1);
        Arrays.sort(str2);
        return Arrays.equals(str1, str2);
    }
}

2. 哈希表

t是s的异位词等价于「两个字符串中字符出现的种类和次数均相等」。
记录s中每个字母出现的频次，然后判断t中每个字母出现的频次-s中字母出现频次是否<0。

• 时间复杂度：$O(n)$
• 空间复杂度：$O(S)$，$S$为字符集大小

class Solution {
    public boolean isAnagram(String s, String t) {
        int[] record = new int[26];
        for (char c : s.toCharArray()) {
            record[c - 'a'] += 1;
        }
        for (char c : t.toCharArray()) {
            record[c - 'a'] -= 1;
        }
        for (int i : record) {
            if (i != 0) {
                return false;
            }
        }
        return true;
    }
} 

二、349. 两个数组的交集

题目描述： 给定两个数组 nums1 和 nums2 ，返回 它们的交集 。

1. HashSet

• 时间复杂度：$O(m+n)$
• 空间复杂度：$O(m+n)$

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        if (nums1 == null || nums1.length == 0 || nums2 == null || nums2.length == 0) {
            return new int[0];
        }
        Set<Integer> set1 = new HashSet<>();
        Set<Integer> resSet = new HashSet<>();
        // 遍历数组1
        for (int i : nums1) {
            set1.add(i);
        }
        // 遍历数组2的过程中判断哈希表中是否存在该元素
        for (int i : nums2) {
            if (set1.contains(i)) {
                resSet.add(i);
            }
        }
        // 将结果几何转为数组
        return resSet.stream().mapToInt(x -> x).toArray();
    }
}

---

三、202. 快乐数

题目描述： 编写一个算法来判断一个数 n 是不是快乐数。
「快乐数」定义为：对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和，然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。如果 可以变为 1，那么这个数就是快乐数。

1.哈希表检测循环

有以下三种可能：

1. 最终会得到 1；
2. 最终会进入循环；
3. 值会越来越大，最后接近无穷大。

• 时间复杂度：$O(logn)$
• 空间复杂度：$O(logn)$

例1：$7^2=49$ >>> $4^2+9^2=97$ >>> … >>> $1^2+0^2=1$
因此，7是快乐数。

例2：让我们从 116 开始。通过反复通过平方和计算下一个数字，我们最终得到 58，再继续计算之后，我们又回到 58。由于我们回到了一个已经计算过的数字，可以知道有一个循环，因此不可能达到 1。
因此，116不是快乐数。

例3：对于 3 位数的数字，它不可能大于 243。这意味着它要么被困在 243 以下的循环内，要么跌到 1。4 位或 4 位以上的数字在每一步都会丢失一位，直到降到 3 位为止。所以我们知道，最坏的情况下，算法可能会在 243 以下的所有数字上循环，然后回到它已经到过的一个循环或者回到 1。但它不会无限期地进行下去，所以我们排除第三种选择。

class Solution {
    public boolean isHappy(int n) {
        Set<Integer> record = new HashSet<>();
        while (n != 1 && !record.contains(n)) {
            record.add(n);
            n = getNextNumber(n);
        }
        return n == 1;
    }
    private int getNextNumber(int n) {
        int res = 0;
        while (n > 0) {
            int temp = n % 10;  // 获取n的最后一位数字
            res += temp * temp;
            n = n / 10;  // 去掉n的最后一位数字
        }
        return res;
    }
}

四、1.两数之和

题目描述： 给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
注：你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

1.暴力枚举

• 时间复杂度：$O(n^2)$
• 空间复杂度：$O(1)$

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

2.哈希表

map中的存储结构为 {key：数据元素，value：数组元素对应的下标}。在遍历数组的时候，只需要向map去查询是否有和目前遍历元素匹配的数值，如果有，就找到的匹配对，如果没有，就把目前遍历的元素放进map中，因为map存放的就是我们访问过的元素。

• 时间复杂度：$O(1)$
• 空间复杂度：$O(1)$

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

---

总结

以上就是今天学习的内容，重点是将题目描述转换为编程描述，今天的内容有哈希表的基础操作，难度较低，较为容易掌握。