hot100 python解法合集

1. 两数之和

python 复制代码

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        hash_map = {}
        for i, num in enumerate(nums):
            complement = target - num
            if complement in hash_map:
                return [hash_map[complement], i]
            if num not in hash_map:
                hash_map[num] = i
        return []

49. 字母异位词分组

python 复制代码

class Solution:
    def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
        anagram_map = collections.defaultdict(list)
        for s in strs:
            key = tuple(sorted(s))
            anagram_map[key].append(s)
        return list(anagram_map.values())

128. 最长连续序列

python 复制代码

class Solution:
    def longestConsecutive(self, nums: List[int]) -> int:
        if not nums:
            return 0
        num_set = set(nums)
        max_len = 0
        for num in num_set:
            if num - 1 in num_set:
                continue
            cur_num = num
            cur_len = 1
            while (cur_num + 1) in num_set:
                cur_len += 1
                cur_num += 1
            if cur_len > max_len:
                max_len = cur_len
        return max_len

核心：使用**哈希集合（HashSet）**来通过空间换时间。

时间复杂度：

O(n)

外层的 for 循环遍历集合中的每个元素。

关键在于 if num - 1 not in num_set 这个判断。这意味着内部的 while 循环只有在找到序列起点时才会执行。

例如对于序列 [1, 2, 3, 4]：

遍历到 2：2-1=1 存在，跳过。

遍历到 3：3-1=2 存在，跳过。

遍历到 4：4-1=3 存在，跳过。

只有遍历到 1 时：1-1=0 不存在，进入 while 循环，访问 2, 3, 4。

因此，数组中的每个数字，最多只会被访问两次（一次是在 for 循环中，一次是在 while 循环中作为后续数字被检查）。所以总操作次数是线性的

283. 移动零

python 复制代码

class Solution:
    def moveZeroes(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        i, j = 0, 0
        for i in range(len(nums)):
            if nums[i] != 0:
                if i > j:
                    nums[j], nums[i] = nums[i], nums[j]
                j += 1

11. 盛最多水的容器

python 复制代码

class Solution:
    def maxArea(self, height: List[int]) -> int:
        max_val = 0
        left, right = 0, len(height) - 1
        while left < right:
            cur_val = min(height[left], height[right]) * (right - left)
            if cur_val > max_val:
                max_val = cur_val
            if height[left] < height[right]:
                left += 1
            else:
                right -= 1
        return max_val

15. 三数之和

python 复制代码

class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        n = len(nums)
        res = []

        nums.sort()
        for i in range(n):
            if nums[i] > 0:
                break
            if i > 0 and nums[i] == nums[i - 1]:
                continue

            left = i + 1
            right = n - 1
            while left < right:
                total = nums[i] + nums[left] + nums[right]
                if total == 0:
                    res.append([nums[i], nums[left], nums[right]])
                    while left < right and nums[left + 1] == nums[left]:
                        left += 1
                    while left < right and nums[right - 1] == nums[right]:
                        right -= 1
                    left += 1
                    right -= 1
                elif total > 0:
                    right -= 1
                else:
                    left += 1
        return res