力扣刷满100题，第一周

力扣刷满100题，第一周

---

1. 两数之和

• 描述

  • 给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标

• 输入示例

  输入：nums = [2,7,11,15], target = 9
  输出：[0,1]
  解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1]

• 算法思想

  • 1. 首先从数组中选取一个元素nums[i]，计算出目标值
  • 2. 遍历剩余的数组，比较目标值是否相同
       • 方法一：暴力思想，直接遍历，比较目标值
       • 方法二：哈希思想，创建一个空的字典，遍历的过程中，看目标值res是否在字典中，如果在则返回对应数值的下标；不在则添加**nums[i]**到字典中
       • 方法三：二分法，首先需要数组中的元素有序，可以使用ZIP方法生成一个带有下标的二维数组集，然后进行排序。
       • 方法四：index方法，在求出目标值后，判断目标值是否在数组中存在，存在则通过**index(res)**获取目标值的下标
  • 3. 返回数组中两个数的下标

• 具体实现

  • 方法一：暴力思想

  class Solution:
      def twoSum(self, nums: List[int], target: int) -> List[int]:
          n = len(nums)
          for i in range(n):
              res = target - nums[i]
              for j in range(i + 1, n):
                  if res == nums[j]:
                      return i, j
          return []
  

  • 方法二：哈希思想

  class Solution:
      def twoSum(self, nums: List[int], target: int) -> List[int]:
          # 创建map
          mp = {}
          for i in range(len(nums)):
              res = target - nums[i]
              if res in mp:
                  return mp[res], i
              # 将数据存放到map
              mp[nums[i]] = i
          return []
  

  • 方法三：二分法

  class Solution:
      def twoSum(self, nums: List[int], target: int) -> List[int]:
          n = len(nums)
          # 带有数组下标排序后的二维数组
          data = sorted(zip(nums, range(n)))
          left, right = 0, n - 1
          while left < right:
              if data[left][0] + data[right][0] == target:
                  return data[left][1], data[right][1]
              elif data[left][0] + data[right][0] > target:
                  right -= 1
              else:
                  left += 1
          return []
  

  • 方法四：index方法

  class Solution:
      def twoSum(self, nums: List[int], target: int) -> List[int]:
          n = len(nums)
          for i in range(n):
              res = target - nums[i]
              # 判断目标值是否存在数组中
              if res in nums[i + 1 :]:
                  return i, nums[i + 1 :].index(res) + i + 1
  

  ---

2. 字母异位词分组

• 描述

  • 给你一个字符串数组，请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。

    字母异位词 是由重新排列源单词的所有字母得到的一个新单词

• 输入示例

  输入：strs = [“eat”, “tea”, “tan”, “ate”, “nat”, “bat”]

  输出：[[“bat”],[“nat”,“tan”],[“ate”,“eat”,“tea”]]

• 算法思想

  • 方法一：哈希思想

    • 首先构建一个空的字典
    • 将strs数组中的每个word排序，看字典中有无该类别
    • 如果有该类别，则将**strs[i]**存入该类别中
      • 如果没有，则将排序好的word存入字典中
    • 将字典的values转换为list集合形式返回

  • 方法二：大佬思想

    • …

• 注意事项

  • 当键不存在的时候需要将word转为数组即***[word]***，然后再放入到字典中
  • 最后需要获取字典的值，并转为list数组形式返回

• 具体实现

  • 方法一：哈希思想

  class Solution:
      def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
          # 定义一个字典，用于存储字母异位词分组结果   anagram ->相同字母异序词
          anagram_dict = {}
          # 遍历所有单词
          for word in strs:
              # 将单词按照字母顺序排序，并作为键
              sorted_word = ''.join(sorted(word))
              # 如果该键已经在字典中，将当前单词加入到对应的列表中
              if sorted_word in anagram_dict:
                  anagram_dict[sorted_word].append(word)
              else:
                  # 如果该键不存在，则创建新的列表，并将当前单词加入其中
                  anagram_dict[sorted_word] = [word]
          # 返回字典中所有值组成的列表，即为结果
          return list(anagram_dict.values())
  

  • 方法二：大佬思想

  class Solution:
      def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
          """
          生成str的哈希值，由str中每个字符和出现的次数拼接而成。
          如字符串str="abcaba"的哈希值为"a3b2c1"
          """
          def get_str_hash(s: str) -> str:
              # 统计str中出现的字符次数
              counts = [0] * 26
              for ch in s:
                  counts[ord(ch) - ord('a')] += 1
              # 生成字符串的哈希字符串
              h = ""
              for i, c in enumerate(counts):
                  if c > 0:
                      h += f"{chr(ord('a') + i)}{c}"      # 加入字符和字符数量
              return h
  
          groups = {}     # 存放字符串哈希值和对应的字符串列表
          # 根据字符串的哈希值进行分组
          for s in strs:
              hash_str = get_str_hash(s)  # 获取字符串的哈希值
              if hash_str not in groups:
                  groups[hash_str] = []   # 哈希值不存在，为这个哈希值新建一个列表
              groups[hash_str].append(s)  # 将当前字符串加入hash对应的列表中
  
          return list(groups.values())    # 分组结果已存在哈希表中，返回所有值组成的列表
  

  ---