代码随想录第 5 天 - 242 有效的字母异位词 & 349 两个数组的交集 & 202 快乐数 & 1 两数之和

哈希表

242 有效的字母异位词

原题链接

解题思路：
分析题义，能够很快的知道是想让我们比较两个字符串字母出现的次数是否相同。统计相同元素的次数，很容易想到用 HashMap。因此有了解法1。

题解 1：
时间复杂度：O(n)
空间复杂度：O(n)

class Solution {
    public boolean isAnagram(String s, String t) {
        char[] ss = s.toCharArray();
        char[] tt = t.toCharArray();
        Map<Character, Integer> map = new HashMap<>();
        for (char c : ss) {
            map.put(c, map.getOrDefault(c, 0) + 1);
        }
        for (char c : tt) {
            if (!map.containsKey(c)) return false;
            map.put(c, map.get(c) - 1);
        }
        for (int val : map.values()) {
            if (val != 0) return false;
        }
        return true;
    }
}

---

题解 2：

这里有个优化策略。在本题中，HashMap 的 key 是字符，通常我们可以采用 int[26] 数组来优化空间。

时间复杂度：O(m + n)：遍历了 s 和 t 两个字符串。如果二者长度相同的话则为 O(n)。
空间复杂度：O(n)：int[26] 数组是固定大小的，所以是O(1)。但是这里使用了 toCharArray() 创建了一个 char 数组，所以空间又变为 O(n) 了。但在本题中也可以直接用 string.charAt() 去遍历每个字符。

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

349 两个数组的交集

原题链接

解题思路：
审题抓住关键字：交集、唯一。瞬间就能联想到用哈希表，这道题用 HashSet 就好了。

题解：
时间复杂度：O(m + n) ：时间复杂度就是遍历两个数组的时间
空间复杂度：O(m + n)：空间复杂度取决于两个 set 的大小

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        Set<Integer> set1 = new HashSet<>();
        for (int i : nums1) {
            set1.add(i);
        }
        Set<Integer> set2 = new HashSet<>();
        for (int i : nums2) {
            if (set1.contains(i)) {
                set2.add(i);
            }
        }
        // set 转 arr 返回
        int[] res = new int[set2.size()];
        int index = 0;
        for (int i : set2) {
            res[index++] = i;
        }
        return res;
    }
}

---

优化策略：这道题数组的取值 0 <= nums1[i], nums2[i] <= 1000。因为是固定大小，所以也可以用数组来优化空间。

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        int[] arr1 = new int[1001];
        int[] arr2 = new int[1001];
        for (int i : nums1) {
            arr1[i]++;
        }
        for (int i : nums2) {
            if (arr1[i] != 0) {
                arr2[i]++;
            }
        }
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < arr2.length; i++) {
            if (arr2[i] != 0) list.add(i);
        }
        // list 转 arr 返回
        int[] res = new int[list.size()];
        for (int i = 0; i < list.size(); i++) {
            res[i] = list.get(i);
        }
        return res;
    }
}

202 快乐数

原题链接

解题思路：
乍一看很🐯人，什么无限循环的。但其实，无限循环就代表了肯定是一直在重复，这样我们每次都收集结果，当开始出现重复时，就返回 false 好了。

题解：
时间复杂度：O(log n)
空间复杂度：O(log n)

这道题的时间和空间复杂度计算很有意思。

• 首先是每次要计算位数的平方和，这部分时间复杂度是 O(log n)。考虑到最坏的情况，也就是平方和是无限循环的。这时候因为我们是递归调用，递归的深度是取决于循环体的大小。我们知道循环体的大小吗？其实不知道，但是我们的是，一个二位数的平方和最多是 9*9 + 9*9 = 162。也就是说二位数的循环体最大就是162。同理，我们也能够知道三位数的循环体的最大大小是 9*9 + 9*9 + 9*9 = 243。说明循环体的大小是常数，递归的深度是常数，所以时间复杂度就是 O(log n)。
• 至于空间复杂度，虽然我们这里用了一个 Set。但是 Set 在本题中是不会存储到重复元素的，因为一重复我们就返回了。Set 存储数字的数量等于递归的深度。已知，d 位数的最大循环体数是 9*9*d，所以递归深度最大也是 81d。然后位数 d 是和 log n 成正比的，所以总的空间复杂度就是 O(log n)。

class Solution {
    private Set<Integer> set = new HashSet<>();

    public boolean isHappy(int n) {
        int sum = 0;
        while (n > 0) {
            int bit = n % 10;
            sum += bit * bit;
            n /= 10;
        }
        if (sum == 1) return true;
        else {
            if (set.contains(sum)) return false;
            set.add(sum);
            return isHappy(sum);
        }
    }
}

1 两数之和

原题链接

解题思路：
万恶之源…分析题义，要求返回的是坐标值。代表我们需要值和下标的一个映射，所以想到用 HashMap。

题解：
时间复杂度：O(n)
空间复杂度：O(n)

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

今日心得

今天效率比较高，也可能是对哈希表比较熟一些。明天继续💪！