Summer Clover1. 问题解析：理解"除自身以外数组的乘积"
给定一个整数数组nums，要求返回一个新数组answer，其中answer[i]等于nums中除nums[i]之外所有元素的乘积。题目要求算法时间复杂度为O(n)，并且不能使用除法运算。
这个问题看似简单，但有几个关键约束条件需要注意：
- 时间复杂度必须为O(n)，这意味着不能使用嵌套循环暴力计算
- 不能使用除法运算，排除了先计算总乘积再除以当前元素的解法
- 需要考虑乘积可能非常大，题目说明输出数组不算作额外空间
1.1 暴力解法的问题分析
最直观的解法是对于每个元素nums[i]，遍历数组计算其他所有元素的乘积：
python复制def productExceptSelf(nums):
n = len(nums)
answer = [1] * n
for i in range(n):
for j in range(n):
if i != j:
answer[i] *= nums[j]
return answer
这种解法的时间复杂度是O(n²)，显然不符合题目要求。我们需要寻找更高效的算法。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 最优解法：左右乘积列表
2.1 算法思路
我们可以通过预处理两个辅助数组来优化时间复杂度：
- left[i]：表示nums[i]左侧所有元素的乘积
- right[i]：表示nums[i]右侧所有元素的乘积
最终answer[i] = left[i] * right[i]
python复制def productExceptSelf(nums):
n = len(nums)
left, right, answer = [1]*n, [1]*n, [1]*n
# 计算左侧乘积
for i in range(1, n):
left[i] = left[i-1] * nums[i-1]
# 计算右侧乘积
for j in range(n-2, -1, -1):
right[j] = right[j+1] * nums[j+1]
# 合并结果
for i in range(n):
answer[i] = left[i] * right[i]
return answer
2.2 时间复杂度分析
这个解法：
- 从左到右遍历一次计算left数组：O(n)
- 从右到左遍历一次计算right数组：O(n)
- 遍历一次合并结果：O(n)
总时间复杂度为O(n)，满足题目要求。
3. 空间优化：常数空间复杂度
虽然上面的解法时间复杂度符合要求，但使用了两个额外数组(left和right)。我们可以进一步优化空间复杂度：
python复制def productExceptSelf(nums):
n = len(nums)
answer = [1] * n
# 先用answer存储左侧乘积
for i in range(1, n):
answer[i] = answer[i-1] * nums[i-1]
# 使用一个变量跟踪右侧乘积
R = 1
for i in range(n-1, -1, -1):
answer[i] = answer[i] * R
R *= nums[i]
return answer
这个优化版本：
- 首先将answer数组用作left数组
- 然后使用一个变量R从右到左累积右侧乘积
- 最终answer[i] = left[i] * R
空间复杂度优化到O(1)（输出数组不算额外空间）。
4. 边界条件与特殊测试用例
在实际编码中，需要考虑以下边界情况：
- 数组长度为0或1的情况
- 数组中包含0的情况
- 数组中包含负数的情况
- 乘积非常大的情况（虽然题目说明输出数组不算额外空间）
测试用例示例：
- 输入：[1,2,3,4] → 输出：[24,12,8,6]
- 输入：[0,1,2,3] → 输出：[6,0,0,0]
- 输入：[1,0] → 输出：[0,1]
- 输入：[1,-1] → 输出：[-1,1]
5. 实际应用场景
这种算法在实际开发中有多种应用场景：
- 图像处理中计算像素周围区域的统计量
- 金融分析中计算除当前数据点外的指标
- 推荐系统中计算用户对某物品的兴趣度时排除自身影响
- 时间序列分析中计算滑动窗口统计量
6. 算法变种与扩展
基于这个核心思路，可以解决一些变种问题：
- 计算除自身外所有元素的求和（更简单，不需要考虑乘积溢出）
- 计算除自身外k个最近邻元素的乘积（滑动窗口变种）
- 多维数组情况下的类似计算（需要扩展到多维）
对于乘积可能非常大的情况，可以考虑在取模的条件下计算，这在一些编程竞赛中常见：
python复制MOD = 10**9 + 7
def productExceptSelf(nums):
n = len(nums)
answer = [1] * n
for i in range(1, n):
answer[i] = (answer[i-1] * nums[i-1]) % MOD
R = 1
for i in range(n-1, -1, -1):
answer[i] = (answer[i] * R) % MOD
R = (R * nums[i]) % MOD
return answer
7. 与其他算法的比较
与类似数组处理问题相比，这个问题的独特之处在于：
- 与"前缀和"问题类似，但使用乘积且不能使用除法
- 与"滑动窗口"问题不同，需要计算的是排除当前元素的全局乘积
- 与"两数之和"等问题相比，更注重空间复杂度的优化
在面试中，面试官可能会逐步引导：
- 先提出暴力解法
- 然后提示优化时间复杂度
- 最后要求优化空间复杂度
8. 编码实现细节
在实际编码中，有几个细节需要注意：
- 初始值的设置（left[0]和right[n-1]应该为1）
- 遍历方向（从左到右和从右到左）
- 乘积的累积方式（是*=还是=*）
- 边界条件的处理（空数组或单元素数组）
C++实现示例：
cpp复制vector<int> productExceptSelf(vector<int>& nums) {
int n = nums.size();
vector<int> answer(n, 1);
// 计算左侧乘积
for (int i = 1; i < n; i++) {
answer[i] = answer[i-1] * nums[i-1];
}
// 计算右侧乘积并合并
int R = 1;
for (int i = n-1; i >= 0; i--) {
answer[i] *= R;
R *= nums[i];
}
return answer;
}
Java实现示例：
java复制public int[] productExceptSelf(int[] nums) {
int n = nums.length;
int[] answer = new int[n];
Arrays.fill(answer, 1);
// 左侧乘积
for (int i = 1; i < n; i++) {
answer[i] = answer[i-1] * nums[i-1];
}
// 右侧乘积
int R = 1;
for (int i = n-1; i >= 0; i--) {
answer[i] *= R;
R *= nums[i];
}
return answer;
}
9. 常见错误与调试技巧
初学者在解决这个问题时容易犯以下错误：
- 忘记处理nums[i]等于0的情况（虽然题目没说有0，但应该考虑）
- 在空间优化版本中错误地更新R的顺序
- 初始值设置不正确（应该初始化为1而不是0）
- 边界条件处理不当（数组长度为0或1时）
调试技巧：
- 先用小数组测试（如[1,2]）
- 打印中间结果（left和right数组）
- 检查乘积是否累积正确
- 特别注意循环的起始和结束索引
10. 性能优化进阶
对于特别大的数组，可以考虑以下优化：
- 并行计算左侧和右侧乘积（使用多线程）
- 分段计算后合并结果（适用于分布式系统）
- 使用SIMD指令加速乘积计算（在支持硬件加速的环境中）
虽然这些优化对算法复杂度没有改变，但在实际工程中可以提升性能：
python复制from threading import Thread
def compute_left(nums, left, start, end):
for i in range(start+1, end):
left[i] = left[i-1] * nums[i-1]
def compute_right(nums, right, start, end):
for i in range(end-2, start-1, -1):
right[i] = right[i+1] * nums[i+1]
def productExceptSelfParallel(nums):
n = len(nums)
left, right = [1]*n, [1]*n
# 将数组分成两部分并行计算
mid = n // 2
t1 = Thread(target=compute_left, args=(nums, left, 0, mid))
t2 = Thread(target=compute_left, args=(nums, left, mid, n))
t3 = Thread(target=compute_right, args=(nums, right, 0, mid))
t4 = Thread(target=compute_right, args=(nums, right, mid, n))
t1.start(); t2.start(); t3.start(); t4.start()
t1.join(); t2.join(); t3.join(); t4.join()
return [left[i]*right[i] for i in range(n)]
这个并行版本在大数组上可能会有更好的性能表现，但增加了实现的复杂性。