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

242. 有效的字母异位词

题目链接

题目描述：
给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。

示例 1: 输入: s = “anagram”, t = “nagaram” 输出: true

示例 2: 输入: s = “rat”, t = “car” 输出: false

说明: 假设字符串只包含小写字母

思路1：
构造两个哈希表进行比较不同字符的个数是否相同

class Solution {
    public boolean isAnagram(String s, String t) {
        if (s.length() != t.length()) return false;

        HashMap<Character, Integer> hm1 = new HashMap<>();
        HashMap<Character, Integer> hm2 = new HashMap<>();
        for (int i = 0; i < s.length(); i++) {
            hm1.put(s.charAt(i), hm1.getOrDefault(s.charAt(i), 0) + 1);
        }
        for (int i = 0; i < t.length(); i++) {
            hm2.put(t.charAt(i), hm2.getOrDefault(t.charAt(i), 0) + 1);
        }
        for (Character key:hm1.keySet()) {
            if (hm1.get(key) != hm2.get(key)) {
                return false;
            }
        }
        return true;
    }
}

有一个点没通过（37/38），可能是字符串给的太大了溢出？？？
在下面的思路中，仅使用一个hashmap就没有问题。

思路2：
由于题中数据规模不大（仅包含小写字母），那么可以使用数组实现哈希表。
另外，由于需要比较对应字母数量是否相同，仅需先加后减，最后排查数组中是否所有元素均为0，这样构造一个数组即可完成。

难点：
选择什么样的数据结构实现哈希表

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

//使用hashmap
class Solution {
    public boolean isAnagram(String s, String t) {
        if (s.length() != t.length()) return false;

        HashMap<Character, Integer> hm = new HashMap<>();
        for (int i = 0; i < s.length(); i++) {
            hm.put(s.charAt(i), hm.getOrDefault(s.charAt(i), 0) + 1);
        }
        for (int i = 0; i < t.length(); i++) {
            hm.put(t.charAt(i), hm.getOrDefault(t.charAt(i), 0) - 1);
        }
        for (Character key : hm.keySet()) {
            if (hm.get(key) != 0) {
                return false;
            }
        }
        return true;
    }
}

//使用数组
class Solution {
    public boolean isAnagram(String s, String t) {
        if (s.length() != t.length()) return false;

        int[] hash = new int[26];
        for (int i = 0; i < s.length(); i++) {
            hash[s.charAt(i)-'a'] += 1;
        }
        for (int i = 0; i < t.length(); i++) {
            hash[t.charAt(i)-'a'] -= 1;
        }
        for (int i = 0; i < 26; i++) {
            if (hash[i] != 0) {
                return false;
            }
        }
        return true;
    }
}

时长：
12min

收获：
确定规模的数据使用数组构造就好

统计出现频率：新构建hashmap的初始化及统计方法
hm.put(s.charAt(i), hm.getOrDefault(s.charAt(i), 0) + 1)

---

349. 两个数组的交集

题目链接

题目描述：
给定两个数组，编写一个函数来计算它们的交集。

思路：
使用数组来做哈希的题目，是因为题目都限制了数值的大小。

而这道题目没有限制数值的大小，就无法使用数组来做哈希表了。

而且如果哈希值比较少、特别分散、跨度非常大，使用数组就造成空间的极大浪费。

此时就要使用另一种结构体了，Set

难点：
对Set类型转化成数组类型

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

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        Set<Integer> set = new HashSet<>();
        Set<Integer> resSet = new HashSet<>();
        
        for (Integer num : nums1) {
            set.add(num);
        }
        
        for (Integer num : nums2) {
            if (set.contains(num)) {
                resSet.add(num);
            }
        }
        
        return resSet.stream().mapToInt(x -> x).toArray();
    }
}

时长：
10min

收获：
Set转化成数组
Set.stream().mapToInt(x -> x).toArray()

---

202. 快乐数

题目链接

题目描述：
编写一个算法来判断一个数 n 是不是快乐数。

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

如果 n 是快乐数就返回 True ；不是，则返回 False 。

示例：

输入：19
输出：true
解释：
1^2 + 9^2 = 82
8^2 + 2^2 = 68
6^2 + 8^2 = 100
1^2 + 0^2 + 0^2 = 1

思路：
如果变不到1，那么就会无限循环，因此，过程中必定产生重复的值。

按照公式进行计算，记录过程中出现的数值
如果出现重复，那么不是快乐数
如果计算值变为1，那么是快乐数

难点：

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

class Solution {
    public boolean isHappy(int n) {
        Set<Integer> hs = new HashSet<>();
        n = getNext(n);
        while (n != 1 && !hs.contains(n)) {
            hs.add(n);
            n = getNext(n);
        }

        return n == 1;
    }

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

时长：
15min

收获：
Set的使用

---

1. 两数之和

题目链接

题目描述：
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9

所以返回 [0, 1]

思路1：
双指针，使用下标标记遍历的终止位置，在这之前的数组部分找是否有满足条件的组合。

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

思路2：
首先我在强调一下什么时候使用哈希法，当我们需要查询一个元素是否出现过，或者一个元素是否在集合里的时候，就要第一时间想到哈希法。

本题呢，我就需要一个集合来存放我们遍历过的元素，然后在遍历数组的时候去询问这个集合，某元素是否遍历过，也就是 是否出现在这个集合。

那么我们就应该想到使用哈希法了。

因为本地，我们不仅要知道元素有没有遍历过，还有知道这个元素对应的下标，需要使用 key value结构来存放，key来存元素，value来存下标，那么使用map正合适。

再来看一下使用数组和set来做哈希法的局限。

• 数组的大小是受限制的，而且如果元素很少，而哈希值太大会造成内存空间的浪费。
• set是一个集合，里面放的元素只能是一个key，而两数之和这道题目，不仅要判断y是否存在而且还要记录y的下标位置，因为要返回x 和 y的下标。所以set 也不能用。

此时就要选择另一种数据结构：map ，map是一种key value的存储结构，可以用key保存数值，用value在保存数值所在的下标。

难点：
注意：同一数值不能重复使用，相同数值若有多个，可以重复使用。

本题其实有四个重点：

• 为什么会想到用哈希表
• 哈希表为什么用map
• 本题map是用来存什么的
• map中的key和value用来存什么的
  把这四点想清楚了，本题才算是理解透彻了。

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

class Solution {
    public int[] twoSum(int[] nums, int target) {
        HashMap<Integer, Integer> hm = new HashMap<>();

        for (int i = 0; i < nums.length; i++) {
            if (hm.containsKey(target-nums[i])) {
                return new int[]{hm.get(target-nums[i]), i};
            }
            hm.put(nums[i], i);
        }
        return null;
    }
}

时长：
20min

收获：
判断hashmap里面有没有相应的东东，直接用contains就好
hm.containsKey(target-nums[i])
不用那么复杂
hm.get(target-nums[i]) != null && hm.get(target-nums[i]) != i