LeetCode 热题 100 Python3 算法题解：哈希、双指针与滑动窗口 | 极客日志

Python算法

LeetCode 热题 100 Python3 算法题解：哈希、双指针与滑动窗口

LeetCode 热题 100 Python3 算法题解，涵盖哈希表、双指针、滑动窗口及子数组等核心数据结构与算法技巧。内容包含两数之和、字母异位词分组、最长连续序列、移动零、盛最多水的容器、三数之和、接雨水、无重复字符的最长子串、找到字符串中所有字母异位词以及和为 K 的子数组等经典题目。提供详细解题思路、Python 代码实现及复杂度分析，适合算法初学者进阶学习。

PentesterX发布于 2026/3/16更新于 2026/4/2615 浏览

哈希

1. 两数之和（简单）

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

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

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

示例 1：

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

示例 2：

输入： nums = [3,2,4], target = 6 输出： [1,2]

示例 3：

输入： nums = [3,3], target = 6 输出： [0,1]

提示：

2 <= nums.length <= 10^4
-10^9 <= nums[i] <= 10^9
-10^9 <= target <= 10^9
只会存在一个有效答案

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

该解法为暴力遍历。直接遍历整个列表，从第一个值开始，如果从当前位置到最后位置中有和当前位置值相加为目标值的即返回这两个位置。

49. 字母异位词分组（中等）

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

class Solution:
    def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
        d = defaultdict(list)
        for s in strs:
            sorted_s = ''.join(sorted(s))
            d[sorted_s].append(s)
        return list(d.values())

class Solution:
    def longestConsecutive(self, nums: List[int]) -> int:
        st = set(nums)
        ans = 0
        for x in st:
            if x - 1 in st:
                continue
            y = x + 1
            while y in st:
                y += 1
            ans = max(ans, y - x)
        return ans

class Solution:
    def moveZeroes(self, nums: List[int]) -> None:
        left = right = 0
        n = len(nums)
        while right < n:
            if nums[right] != 0:
                nums[left], nums[right] = nums[right], nums[left]
                left += 1
            right += 1

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

class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        nums.sort()
        res, k = [], 0
        for k in range(0, len(nums) - 2):
            if nums[k] > 0:
                break
            if k > 0 and nums[k] == nums[k - 1]:
                continue
            i, j = k + 1, len(nums) - 1
            while i < j:
                s = nums[k] + nums[i] + nums[j]
                if s < 0:
                    i += 1
                    while i < j and nums[i] == nums[i - 1]:
                        i += 1
                elif s > 0:
                    j -= 1
                    while i < j and nums[j] == nums[j + 1]:
                        j -= 1
                else:
                    res.append([nums[k], nums[i], nums[j]])
                    i += 1
                    j -= 1
                    while i < j and nums[i] == nums[i - 1]:
                        i += 1
                    while i < j and nums[j] == nums[j + 1]:
                        j -= 1
        return res

class Solution:
    def trap(self, height: List[int]) -> int:
        n = len(height)
        res = 0
        left, right = 0, n - 1
        leftmax, rightmax = height[left], height[right]
        left += 1
        right -= 1
        while left <= right:
            leftmax = max(leftmax, height[left])
            rightmax = max(rightmax, height[right])
            if leftmax < rightmax:
                res += leftmax - height[left]
                left += 1
            else:
                res += rightmax - height[right]
                right -= 1
        return res

class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:
        dic, res, i = {}, 0, -1
        for j in range(len(s)):
            if s[j] in dic:
                i = max(dic[s[j]], i)
            dic[s[j]] = j
            res = max(res, j - i)
        return res

class Solution:
    def findAnagrams(self, s: str, p: str) -> List[int]:
        m, n, res = len(s), len(p), []
        if n > m:
            return res
        s_cnt = [0] * 26
        p_cnt = [0] * 26
        for i in range(n):
            s_cnt[ord(s[i]) - ord('a')] += 1
            p_cnt[ord(p[i]) - ord('a')] += 1
        if s_cnt == p_cnt:
            res.append(0)
        for i in range(n, m):
            s_cnt[ord(s[i - n]) - ord('a')] -= 1
            s_cnt[ord(s[i]) - ord('a')] += 1
            if s_cnt == p_cnt:
                res.append(i - n + 1)
        return res

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

class Solution:
    def subarraySum(self, nums: List[int], k: int) -> int:
        res = 0
        n = len(nums)
        presums = defaultdict(int)
        presums[0] = 1
        presum = 0
        for i in range(n):
            presum += nums[i]
            res += presums[presum - k]
            presums[presum] += 1
        return res