LeeCode哈希问题（一）

LeeCode 242: 有效的字母异位词

题目描述：

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

标签： 哈希表，字符串

时间复杂度： O(N + M)，N表示字符串长度，M表示字符种类

建立模型：

1. 比较 s 和 t 的长度，若不相等则不可能为字母异位词 return False，若相等则继续第二步
2. 统计 s 和 t 中各个字符出现的次数（使用两个哈希表保存）
3. 比较这两个哈希表保存的内容是否一致

代码实现：

# 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)

建立模型：

1. 去除原始数组中的重复元素
2. 求两个数组都包含的元素
3. 返回结果

代码实现：

# 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. 计算正整数的各位置上数字的平方和，并保存至集合中
2. 重复第1步，直到这个过程的结果为1，或者出现已经保存的在集合中的数字
3. 结果为1 \(\rightarrow\) 该数是快乐数
4. 出现已保存在集合中的数字 \(\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)

建立模型：

1. 从头开始遍历数组 nums
2. 对于遍历到的每个 num，记录其相加等于 target 需要的另一个值 和 自己的索引位置
3. 若直至数组末尾都未找到，则该数组不存这样的两个数相加等于 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;
}