和为K的子数组（前缀和思想）

题目描述
给定一个整数数组和一个整数 k，你需要找到该数组中和为 k 的连续的子数组的个数。

示例 1 :

输入:nums = [1,1,1], k = 2
输出: 2 , [1,1] 与 [1,1] 为两种不同的情况。
说明 :

数组的长度为 [1, 20,000]。
数组中元素的范围是 [-1000, 1000] ，且整数 k 的范围是 [-1e7, 1e7]。

引入前缀和
前缀和 定义：nums 的第 0 项到 当前项 的和。
用一个数组 prefixSum 表示，prefixSum[x]：第 0 项到 第 x 项 的和。
prefixSum[x] = nums[0] + nums[1] +…+nums[x]

nums 的某项 = 两个相邻前缀和的差：
nums[x] = prefixSum[x] - prefixSum[x - 1]

nums 的 第 i 到 j 项 的和，即子数组的和：
nums[i] +…+nums[j]=prefixSum[j] - prefixSum[i - 1]

i 可以为 0，此时 i - 1 为 - 1，我们故意让 prefixSum[-1] 为 0，使得该通式在边界情况也成立，此时：
nums[0] +…+nums[j]=prefixSum[j]

题目的等价转化
题意：有几种 i、j 的组合，使得从第 i 到 j 项的子数组求和等于 k。
↓ ↓ ↓ 转化为 ↓ ↓ ↓
有几种 i、j 的组合，满足 prefixSum[j] - prefixSum[i - 1] == kprefixSum[j]−prefixSum[i−1]==k。
我们可以求出 prefixSum 数组的每一项，再看哪些项相减等于k，求出count。
但该通式有 2 个变量，需要两层循环才能找出哪些项相减等于 k，依旧是 O(n^2)。
不用求出 prefixSum 数组，引入哈希表
我们只关心哪些前缀和的值相减等于k，我们不关心具体是哪一项的前缀和相减等于k，并且我们关心前缀和的值出现的次数，这样我们就知道有几个子数组求和等于k。
出现过的前缀和，和对应的出现次数，存入 map
key：前缀和的值
value：该前缀和出现的次数
遍历 nums 之前，我们让 -1 情况下的前缀和为 0，这样通式在边界情况也能适用。即 map 初始放入 0:1 键值对，即已经出现 1 次前缀和为 0
遍历 nums 数组，求出当前项的前缀和，存入 map：
之前没有存过，则存入，值为 1。
之前存过，则值 +1。
边存边查看 map，如果 map 中存在 key 为：当前前缀和 - k
说明这个之前出现的前缀和，满足「当前前缀和 - 该前缀和 == k」。该前缀和出现的次数，累加给 count。
一句话总结
根据当前前缀和，在 map 中寻找「与之相减 == k」的前缀和。该前缀和出现过 n 次，就等价于，能找到 n 个子数组的求和等于 k，随着遍历 nums 数组，n 不断累加给 count，最后返回 count。

代码

const subarraySum = (nums, k) => {
  if (nums.length == 0) return 0;
  
  const map = { 0: 1 };
  let prefixSum = 0;
  let count = 0;

  for (let i = 0; i < nums.length; i++) {
    prefixSum += nums[i];

    if (map[prefixSum - k]) {
      count += map[prefixSum - k];
    }

    if (map[prefixSum]) {
      map[prefixSum]++;
    } else {
      map[prefixSum] = 1;
    }
  }
  return count;
};

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