LeeCode哈希问题（一）
LeeCode 242: 有效的字母异位词
题目描述：
给定两个字符串
s和t，编写一个函数来判断t是否是s的字母异位词。若s和t中每个字符出现的次数都相同，则称互为字母异位词。
标签： 哈希表，字符串
时间复杂度： O(N + M)，N表示字符串长度，M表示字符种类
建立模型：
- 比较
s和t的长度，若不相等则不可能为字母异位词return False，若相等则继续第二步 - 统计
s和t中各个字符出现的次数（使用两个哈希表保存） - 比较这两个哈希表保存的内容是否一致
代码实现：
# Python3 实现
def isAnagram(self, s: str, t: str) -> bool:
if len(s) != len(t):
return False
dict_s, dict_t = {}, {}
for i in range(len(s)):
dict_s[s[i]] = dict_s.get(s[i], 0) + 1
dict_t[t[i]] = dict_t.get(t[i], 0) + 1
# 比较哈希表是否一致
if len(dict_s) != len(dict_t):
return False
for key in dict_s.keys():
if dict_s.get(key) != dict_t.get(key, 0):
return False
return True
// Java 实现
public boolean isAnagram(String s, String t) {
if (s.length() != t.length()) {
return false;
}
Map<Character, String> map = new HashMap<>();
for (int i = 0; i < s.length(); i++) {
map.put(s.charAt(i), map.getOrDefault(s.charAt(i), 0) + 1);
}
for (int i = 0; i < t.length(); i++) {
char c = t.charAt(i);
// 出现一次则计数减一
map.put(c, map.getOrDefault(c, 0) - 1);
// 当出现字符计数小于0时说明不一致
if (map.get(c) < 0) {
return false;
}
}
return true;
}
LeeCode 349: 两个数组的交集
题目描述：
给定两个数组
nums1和nums2，返回它们的交集。输出结果中每个元素一定是唯一的。不考虑元素输出的顺序。
标签： 哈希表，数组
时间复杂度： O(N)
建立模型：
- 去除原始数组中的重复元素
- 求两个数组都包含的元素
- 返回结果
代码实现：
# Python3 实现
def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
# set(nums1) 去除重复元素
# set.intersection 求交集
return list(set(nums1).intersection(set(nums2)))
// Java 实现
public int[] intersection(int[] nums1, int[] nums2) {
if (num1.length == 0 || nums2.length == 0) {
return new int[0];
}
Set<Integer> set = new HashSet<>();
Set<Integer> common = new HashSet<>();
for (int num : nums1) {
set.add(num);
}
for (int num : nums2) {
if (set.contains(num)) {
common.add(num);
}
}
int[] res = new int[common.size()];
int index = 0;
for (int num : common) {
res[index] = num;
index += 1;
}
return res;
}
LeeCode 202: 快乐数
题目描述：
快乐数定义为：
- 对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和
- 然后重复这个过程直到变为1，也可能无限循环但始终变不到1
- 如果这个过程的结果为1，则原始正整数就是快乐数
标签： 哈希表，数学
建立模型：
- 计算正整数的各位置上数字的平方和，并保存至集合中
- 重复第1步，直到这个过程的结果为1，或者出现已经保存的在集合中的数字
- 结果为1 \(\rightarrow\) 该数是快乐数
- 出现已保存在集合中的数字 \(\rightarrow\) 进入无限循环，不是快乐数
代码实现：
# Python3 实现
def isHappy(self, n: int) -> bool:
history = set()
cur = self.getSquares(n)
while cur != 1:
if cur in history:
return False
history.add(cur)
cur = self.getSquares(cur)
return True
def getSquares(self, n: int) -> int:
s = 0
while n:
s += pow(n % 10, 2)
n //= 10
return s
// Java 实现
public boolean isHappy(int n) {
Set<Integer> set = new HashSet<>();
int cur = getSquares(n);
while (cur != 1) {
if (set.contains(cur)) {
return false;
}
set.add(cur);
cur = getSquares(cur);
}
return true;
}
public int getSquares(int n) {
int s = 0;
while (n > 0) {
s += Math.pow(n % 10, 2);
n /= 10;
}
return s;
}
LeeCode 1: 两数之和
题目描述：
给定一个整数数组
nums和一个整数目标值target，请你在该数组中找出 和为目标值target的那 两个 整数，并返回它们的数组下标。你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。你可以按任意顺序返回答案。
标签： 哈希表，数组
时间复杂度： O(N)
建立模型：
- 从头开始遍历数组 nums
- 对于遍历到的每个 num，记录其相加等于 target 需要的另一个值 和 自己的索引位置
- 若直至数组末尾都未找到，则该数组不存这样的两个数相加等于 target
代码实现：
# Python3 实现
def twoSum(self, nums: List[int], target: int) -> List[int]:
dict = {}
for index, num in enumerate(nums):
if num in dict:
return [dict.get(num), index]
else:
dict[target - num] = index
return None
// Java 实现
public int[] twoSum(int[] nums, int target) {
Map<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < nums.length; i++) {
if (map.containsKey(nums[i])) {
return new int[]{map.get(nums[i]), i};
}
else {
map.put(target - nums[i], i);
}
}
return null;
}
