两数之和

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

你可以假设每种输入只会对应一个答案，并且你不能使用两次相同的元素。

你可以按任意顺序返回答案。

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        # 创建一个哈希表（字典），用于存储已经遍历过的数字及其下标
        num_map = {}
        # 遍历数组，同时记录下标和数值
        for index, num in enumerate(nums):
            # 计算当前数字需要的补数（target - 当前数字）
            complement = target - num 
            # 如果补数已经在哈希表中，说明找到了答案
            if complement in num_map:
                # 返回补数的下标和当前下标
                return [num_map[complement], index] 
            # 如果补数不在哈希表中，将当前数字和下标存入哈希表
            num_map[num] = index 
        # 根据题目要求，输入必有解，这里只是防止代码报错
        return []

字母异位词分组

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

class Solution:
    def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
        # 初始化默认字典，键为排序后的字符串，值为对应的字母异位词列表
        anagram_map = defaultdict(list) 
        # 遍历每个字符串
        for s in strs:
            # 对字符串的字符排序，生成唯一标识（字母异位词排序后结果相同）
            # sorted(s) 返回字符列表，join转为字符串作为键
            key = ''.join(sorted(s))
            # 将原字符串加入对应键的列表中
            anagram_map[key].append(s) 
        # 将字典的值转换为列表返回（即所有分组）
        return list(anagram_map.values())	

最长连续序列

给定一个未排序的整数数组 nums ，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。

请你设计并实现时间复杂度为 O(n) 的算法解决此问题。

class Solution:
    def longestConsecutive(self, nums: List[int]) -> int:
        if not nums:  # 处理空数组边界情况
            return 0 
        # 转成集合，去重且O(1)查找
        num_set = set(nums)
        max_length = 0 
        # 遍历每个数，只处理连续序列的起点
        for num in num_set:
            # 只有当num-1不存在时，num才是连续序列的起点
            if num - 1 not in num_set:
                current_num = num
                current_length = 1 
                # 向后找连续的数，统计长度
                while current_num + 1 in num_set:
                    current_num += 1
                    current_length += 1 
                # 更新最长长度
                max_length = max(max_length, current_length) 
        return max_length

移动零

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

请注意 ，必须在不复制数组的情况下原地对数组进行操作。

class Solution:
    def moveZeroes(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        # 慢指针：记录下一个非零元素应该放置的位置
        slow = 0
        # 快指针：遍历数组寻找非零元素
        for fast in range(len(nums)):
            if nums[fast] != 0:
                # 将非零元素放到慢指针位置
                nums[slow] = nums[fast]
                slow += 1 
        # 将慢指针之后的所有位置置为 0
        for i in range(slow, len(nums)):
            nums[i] = 0

盛最多水的容器

给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。

找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

返回容器可以储存的最大水量。

说明：你不能倾斜容器。

class Solution:
    def maxArea(self, height: List[int]) -> int:
        # 初始化左右指针和最大面积
        left = 0
        right = len(height) - 1
        max_water = 0 
        # 双指针向中间移动，直到相遇
        while left < right:
            # 计算当前容器的宽度（指针间距）
            width = right - left
            # 计算当前容器的高度（取两边较矮的高度）
            current_height = min(height[left], height[right])
            # 计算当前储水量
            current_water = width * current_height 
            # 更新最大储水量
            if current_water > max_water:
                max_water = current_water 
            # 移动较矮的指针（核心逻辑）
            if height[left] < height[right]:
                left += 1
            else:
                right -= 1 
        return max_water