LeetCode Hot100（9/100）—— 560. 和为 K 的子数组

文章目录

- 一、题目描述
- - 示例：
- 二、解题思路总览
- 三、解法一：暴力枚举法
- - 思路流程图
  - [Java 代码实现](#Java 代码实现)
  - 复杂度分析
- 四、解法二：前缀和优化版
- - 步骤示意图
  - [Java 代码实现](#Java 代码实现)
  - 复杂度分析
- [五、解法三：前缀和 + 哈希表优化版（最优解）](#五、解法三：前缀和 + 哈希表优化版（最优解）)
- - 思维导图
  - 流程演示
  - [Java 代码实现](#Java 代码实现)
  - 复杂度分析
- 总结

一、题目描述

题意：

给定一个整数数组 nums 和一个整数 k，请你找出数组中 和等于 k 的子数组的个数。

示例：

复制代码

输入：nums = [1,1,1], k = 2
输出：2
解释：子数组 [1,1] 有两个 ------ 第一个与第二个元素组成、第二个与第三个元素组成。

二、解题思路总览

Subarray Sum Equals K
暴力枚举
计算所有子数组的和
n^2
前缀和优化
用 prefix[i] 表示前 i 个元素的和
通过 prefix[j]-prefix[i] 判断子数组和
时间复杂度 O(n^2)，空间 O(n)
哈希表优化
利用 Map 记录前缀和出现次数
prefixSum - k 能找到匹配数
时间复杂度 O(n)，空间 O(n)

三、解法一：暴力枚举法

核心思想：

穷举所有可能的子数组 [i, j]，计算它们的和，若等于 k，计入答案。

思路流程图

是
否
开始
初始化 count = 0
遍历 i 从 0 到 n-1
初始化 sum = 0
遍历 j 从 i 到 n-1
累加 sum += nums[j]
sum == k ?
计数 count++
继续 j++
输出 count
结束

Java 代码实现

java 复制代码

public class SubarraySumEqualsK {
    public int subarraySum(int[] nums, int k) {
        int count = 0;
        for (int i = 0; i < nums.length; i++) {
            int sum = 0;
            for (int j = i; j < nums.length; j++) {
                sum += nums[j];
                if (sum == k) {
                    count++;
                }
            }
        }
        return count;
    }
}

复杂度分析

时间复杂度：O(n²)
空间复杂度：O(1)

四、解法二：前缀和优化版

核心思想：

创建一个前缀和数组 prefixSum[i] 表示从开头到第 i 个元素的累积和。

子数组 [i, j] 的和即为 prefixSum[j] - prefixSum[i-1]。

步骤示意图

nums: [1,2,3]
prefix[0]=0
prefix[1]=1
prefix[2]=3
prefix[3]=6
计算 prefix[j]-prefix[i]

Java 代码实现

java 复制代码

public class SubarraySumEqualsK {
    public int subarraySum(int[] nums, int k) {
        int n = nums.length;
        int[] prefix = new int[n + 1];
        int count = 0;

        for (int i = 1; i <= n; i++) {
            prefix[i] = prefix[i - 1] + nums[i - 1];
        }

        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j <= n; j++) {
                if (prefix[j] - prefix[i] == k) {
                    count++;
                }
            }
        }
        return count;
    }
}

复杂度分析

时间复杂度：O(n²)
空间复杂度：O(n)

五、解法三：前缀和 + 哈希表优化版（最优解）

核心思想：

在遍历数组时，用一个哈希表记录"前缀和出现的次数"。

当我们计算出当前 prefixSum 后，如果存在 prefixSum - k 的记录，说明之前有一个前缀和使得当前这段子数组的和为 k。

思维导图

哈希表优化
当前前缀和 prefixSum
查找 prefixSum - k 是否存在
若存在，对应次数累加到结果
更新哈希表中 prefixSum 出现次数

流程演示

假设 nums = [1, 2, 3], k = 3

步骤	当前数字	prefixSum	prefixSum-k	HashMap状态	count结果
1	1	1	-2	{0:1,1:1}	0
2	2	3	0	{0:1,1:1,3:1}	1（找到1次）
3	3	6	3	{0:1,1:1,3:1,6:1}	2（再找到一次）

Java 代码实现

java 复制代码

import java.util.HashMap;
import java.util.Map;

public class SubarraySumEqualsK {
    public int subarraySum(int[] nums, int k) {
        Map<Integer, Integer> prefixCount = new HashMap<>();
        prefixCount.put(0, 1); // 初始前缀和为 0
        int prefixSum = 0;
        int count = 0;

        for (int num : nums) {
            prefixSum += num;
            if (prefixCount.containsKey(prefixSum - k)) {
                count += prefixCount.get(prefixSum - k);
            }
            prefixCount.put(prefixSum, prefixCount.getOrDefault(prefixSum, 0) + 1);
        }

        return count;
    }
}

复杂度分析

时间复杂度：O(n)
空间复杂度：O(n)

总结

解法类型	时间复杂度	空间复杂度	适用场景
暴力枚举	O(n²)	O(1)	数据规模较小
前缀和优化	O(n²)	O(n)	理解前缀和概念
哈希表优化	O(n)	O(n)	最优解法，适合大规模数据