数组题常用 Python 代码模板

1. 遍历数组模板#

适合：

求和
最大值/最小值
统计次数
判断是否存在某个条件

1
def traverse(nums):
2
    for x in nums:
3
        print(x)

如果需要下标：

1
def traverse_with_index(nums):
2
    for i in range(len(nums)):
3
        print(i, nums[i])

如果同时要下标和值：

1
def traverse_with_enumerate(nums):
2
    for i, x in enumerate(nums):
3
        print(i, x)

2. 查找目标值模板#

2.1 线性查找#

适合无序数组。

1
def linear_search(nums, target):
2
    for i, x in enumerate(nums):
3
        if x == target:
4
            return i
5
    return -1

2.2 二分查找#

适合有序数组。

1
def binary_search(nums, target):
2
    left, right = 0, len(nums) - 1
3

4
    while left <= right:
5
        mid = left + (right - left) // 2
6

7
        if nums[mid] == target:
8
            return mid
9
        elif nums[mid] < target:
10
            left = mid + 1
11
        else:
12
            right = mid - 1
13

14
    return -1

3. 找左边界 / 右边界模板#

适合：

查找第一个等于 target 的位置
查找最后一个等于 target 的位置
查找满足条件的边界

3.1 找左边界#

1
def left_bound(nums, target):
2
    left, right = 0, len(nums) - 1
3
    ans = -1
4

5
    while left <= right:
6
        mid = left + (right - left) // 2
7
        if nums[mid] >= target:
8
            if nums[mid] == target:
9
                ans = mid
10
            right = mid - 1
11
        else:
12
            left = mid + 1
13

14
    return ans

3.2 找右边界#

1
def right_bound(nums, target):
2
    left, right = 0, len(nums) - 1
3
    ans = -1
4

5
    while left <= right:
6
        mid = left + (right - left) // 2
7
        if nums[mid] <= target:
8
            if nums[mid] == target:
9
                ans = mid
10
            left = mid + 1
11
        else:
12
            right = mid - 1
13

14
    return ans

4. 双指针模板#

4.1 左右指针模板#

适合：

反转数组
回文判断
有序数组两数之和

1
def two_pointers_opposite(nums):
2
    left, right = 0, len(nums) - 1
3

4
    while left < right:
5
        # 根据题意处理 nums[left], nums[right]
6
        left += 1
7
        right -= 1

例：反转数组#

1
def reverse_array(nums):
2
    left, right = 0, len(nums) - 1
3

4
    while left < right:
5
        nums[left], nums[right] = nums[right], nums[left]
6
        left += 1
7
        right -= 1
8

9
    return nums

例：有序数组两数之和#

1
def two_sum_sorted(nums, target):
2
    left, right = 0, len(nums) - 1
3

4
    while left < right:
5
        s = nums[left] + nums[right]
6
        if s == target:
7
            return [left, right]
8
        elif s < target:
9
            left += 1
10
        else:
11
            right -= 1
12

13
    return []

4.2 快慢指针模板#

适合：

删除元素
删除重复元素
移动零
原地压缩

1
def fast_slow_pointer(nums):
2
    slow = 0
3

4
    for fast in range(len(nums)):
5
        if 满足条件:
6
            nums[slow] = nums[fast]
7
            slow += 1
8

9
    return slow   # 新长度

例：移除指定元素#

1
def remove_element(nums, val):
2
    slow = 0
3

4
    for fast in range(len(nums)):
5
        if nums[fast] != val:
6
            nums[slow] = nums[fast]
7
            slow += 1
8

9
    return slow

例：移动零#

1
def move_zeroes(nums):
2
    slow = 0
3

4
    for fast in range(len(nums)):
5
        if nums[fast] != 0:
6
            nums[slow], nums[fast] = nums[fast], nums[slow]
7
            slow += 1
8

9
    return nums

例：有序数组去重#

1
def remove_duplicates(nums):
2
    if not nums:
3
        return 0
4

5
    slow = 1
6
    for fast in range(1, len(nums)):
7
        if nums[fast] != nums[fast - 1]:
8
            nums[slow] = nums[fast]
9
            slow += 1
10

11
    return slow

5. 滑动窗口模板#

适合：

最长连续子数组
最短连续子数组
满足条件的连续区间

1
def sliding_window(nums):
2
    left = 0
3
    ans = 0
4
    window = 0   # 根据题意维护窗口信息
5

6
    for right in range(len(nums)):
7
        # 1. 扩大窗口
8
        window += nums[right]
9

10
        # 2. 判断是否需要缩小窗口
11
        while 需要缩小窗口:
12
            window -= nums[left]
13
            left += 1
14

15
        # 3. 更新答案
16
        ans = max(ans, right - left + 1)
17

18
    return ans

例：长度最小的子数组和#

1
def min_subarray_len(target, nums):
2
    left = 0
3
    total = 0
4
    ans = float('inf')
5

6
    for right in range(len(nums)):
7
        total += nums[right]
8

9
        while total >= target:
10
            ans = min(ans, right - left + 1)
11
            total -= nums[left]
12
            left += 1
13

14
    return 0 if ans == float('inf') else ans

6. 前缀和模板#

适合：

区间和查询
子数组和问题
连续区间统计

6.1 构建前缀和#

1
def build_prefix_sum(nums):
2
    prefix = [0] * (len(nums) + 1)
3

4
    for i in range(len(nums)):
5
        prefix[i + 1] = prefix[i] + nums[i]
6

7
    return prefix

6.2 查询区间和 [left, right]#

1
def range_sum(prefix, left, right):
2
    return prefix[right + 1] - prefix[left]

完整示例#

1
def prefix_sum_example(nums, left, right):
2
    prefix = [0] * (len(nums) + 1)
3

4
    for i in range(len(nums)):
5
        prefix[i + 1] = prefix[i] + nums[i]
6

7
    return prefix[right + 1] - prefix[left]

7. 哈希表模板#

适合：

两数之和
统计频率
判断是否重复
查找是否存在

7.1 两数之和#

1
def two_sum(nums, target):
2
    mp = {}
3

4
    for i, x in enumerate(nums):
5
        if target - x in mp:
6
            return [mp[target - x], i]
7
        mp[x] = i
8

9
    return []

7.2 统计频率#

1
def count_frequency(nums):
2
    freq = {}
3

4
    for x in nums:
5
        freq[x] = freq.get(x, 0) + 1
6

7
    return freq

7.3 判断是否有重复#

1
def contains_duplicate(nums):
2
    seen = set()
3

4
    for x in nums:
5
        if x in seen:
6
            return True
7
        seen.add(x)
8

9
    return False

8. 排序后处理模板#

适合：

去重
合并区间
三数之和
第 k 大/小问题

1
def sort_then_process(nums):
2
    nums.sort()
3

4
    for i in range(len(nums)):
5
        # 排序后按题意处理
6
        pass

8.1 合并区间模板#

1
def merge(intervals):
2
    intervals.sort(key=lambda x: x[0])
3
    res = []
4

5
    for interval in intervals:
6
        if not res or res[-1][1] < interval[0]:
7
            res.append(interval)
8
        else:
9
            res[-1][1] = max(res[-1][1], interval[1])
10

11
    return res

9. 子数组问题模板#

适合：

最大子数组和
固定长度子数组统计
连续区间最优值

9.1 最大子数组和（Kadane）#

1
def max_subarray(nums):
2
    cur = nums[0]
3
    ans = nums[0]
4

5
    for i in range(1, len(nums)):
6
        cur = max(nums[i], cur + nums[i])
7
        ans = max(ans, cur)
8

9
    return ans

10. 原地修改模板#

适合：

原地删除
原地覆盖
原地交换

1
def inplace_modify(nums):
2
    slow = 0
3

4
    for fast in range(len(nums)):
5
        if 满足保留条件:
6
            nums[slow] = nums[fast]
7
            slow += 1
8

9
    return nums[:slow]

11. 矩阵（二维数组）遍历模板#

适合：

二维数组
矩阵题
网格遍历

1
def traverse_matrix(matrix):
2
    rows, cols = len(matrix), len(matrix[0])
3

4
    for i in range(rows):
5
        for j in range(cols):
6
            print(matrix[i][j])

12. 原地旋转矩阵模板（90度顺时针）#

1
def rotate(matrix):
2
    n = len(matrix)
3

4
    # 转置
5
    for i in range(n):
6
        for j in range(i + 1, n):
7
            matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]
8

9
    # 每一行反转
10
    for row in matrix:
11
        row.reverse()
12

13
    return matrix

13. 固定窗口模板#

适合：

长度固定的子数组最大和
固定长度统计问题

1
def fixed_window(nums, k):
2
    if len(nums) < k:
3
        return None
4

5
    window_sum = sum(nums[:k])
6
    ans = window_sum
7

8
    for right in range(k, len(nums)):
9
        window_sum += nums[right]
10
        window_sum -= nums[right - k]
11
        ans = max(ans, window_sum)
12

13
    return ans

14. 常用输入处理模板（面试/笔试常见）#

1
nums = list(map(int, input().split()))

二维数组输入：

1
n, m = map(int, input().split())
2
matrix = [list(map(int, input().split())) for _ in range(n)]

15. 数组题调试模板#

做数组题时，调试很重要，可以加打印观察指针变化。

1
def debug_two_pointers(nums):
2
    left, right = 0, len(nums) - 1
3

4
    while left < right:
5
        print(f"left={left}, right={right}, nums[left]={nums[left]}, nums[right]={nums[right]}")
6
        left += 1
7
        right -= 1

16. 数组题万能思考模板#

拿到一道题，先问自己：

1
# 1. 需要遍历统计吗？
2
# 2. 数组有序吗？能二分吗？
3
# 3. 是连续区间问题吗？能滑动窗口吗？
4
# 4. 能用双指针吗？
5
# 5. 需要频繁求区间和吗？能前缀和吗？
6
# 6. 能排序后处理吗？
7
# 7. 能用哈希表优化吗？
8
# 8. 要求原地修改吗？

17. 最常用模板速查版#

如果你只想记最核心的，优先记这 7 个：

1）遍历#

1
for i, x in enumerate(nums):
2
    pass

2）二分查找#

1
left, right = 0, len(nums) - 1
2
while left <= right:
3
    mid = left + (right - left) // 2

3）左右双指针#

1
left, right = 0, len(nums) - 1
2
while left < right:
3
    pass

4）快慢指针#

1
slow = 0
2
for fast in range(len(nums)):
3
    if 条件:
4
        nums[slow] = nums[fast]
5
        slow += 1

5）滑动窗口#

1
left = 0
2
for right in range(len(nums)):
3
    while 需要缩小:
4
        left += 1

6）前缀和#

1
prefix = [0] * (len(nums) + 1)
2
for i in range(len(nums)):
3
    prefix[i + 1] = prefix[i] + nums[i]

7）哈希表#

1
mp = {}
2
for i, x in enumerate(nums):
3
    pass

如果你愿意，我下一步可以继续给你整理成这几种版本之一：

数组题 Python 模板精简版（一页背诵）
LeetCode 数组高频题对应模板
每个模板配 1 道经典例题
数组题常用 Python 技巧总结（切片、enumerate、sorted、zip 等）