力扣-238.除自身以外数组的乘积-CSDN博客

本文链接：https://blog.csdn.net/weixin_67851619/article/details/147724286

本文旨在记录我的解题思路与思考过程（部分解法参考了其他优秀题解，参考来源已附文末），作为个人学习笔记以便后续复习回顾。文中如有疏漏或不足之处，欢迎指正交流。

一. 题述：

给你一个整数数组 nums，返回数组 answer ，其中 answer[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积。

题目数据保证数组 nums之中任意元素的全部前缀元素和后缀的乘积都在 32 位 整数范围内。

请 不要使用除法，且在 O(n) 时间复杂度内完成此题。

二. 解题思路：

2.1 理解题意：

这道题目属于数组操作和前缀/后缀乘积问题。具体来说，它考察的是如何高效地计算数组中每个元素除自身外其他所有元素的乘积，同时满足以下约束：

不能使用除法：排除了“先计算总乘积，再除以当前元素”的直观解法。
时间复杂度 O(n)：要求算法必须在线性时间内完成，不能用暴力嵌套循环（暴力法时间复杂度为 O(n²)）。
空间复杂度优化：理想情况下，除输出数组外，额外空间应为 O(1)。

这类问题的核心思想是预处理前缀和后缀信息，通过空间换时间（或优化空间）的方式避免重复计算。

我作为一个新手，我想的就是暴力嵌套循环。即，将nums数组copy，然后将copy数组里的nums[i]删除，最后将数组每个元素相乘，但是这个方法的时间复杂度是O(n²)。之后看来官方题解的左右乘积列表以及空间复杂度 O(1) 的方法。

2.2 解题步骤:

2.2.1 方法一：左右乘积列表

思路

我们不必将所有数字的乘积除以给定索引处的数字得到相应的答案，而是利用索引左侧所有数字的乘积和右侧所有数字的乘积（即前缀与后缀）相乘得到答案。

对于给定索引 i，我们将使用它左边所有数字的乘积乘以右边所有数字的乘积。

算法

        初始化两个空数组 L 和 R。对于给定索引 i，L[i] 代表的是 i 左侧所有数字的乘积，R[i] 代表的是 i 右侧所有数字的乘积。
        我们需要用两个循环来填充 L 和 R 数组的值。对于数组 L，L[0] 应该是 1，因为第一个元素的左边没有元素。对于其他元素：L[i] = L[i-1] * nums[i-1]。
        同理，对于数组 R，R[length-1] 应为 1。length 指的是输入数组的大小。其他元素：R[i] = R[i+1] * nums[i+1]。
        当 R 和 L 数组填充完成，我们只需要在输入数组上迭代，且索引 i 处的值为：L[i] * R[i]。

2.2.2 方法二：空间复杂度 O(1) 的方法

思路

尽管方法一已经能够很好的解决这个问题，但是空间复杂度并不为常数。

由于输出数组不算在空间复杂度内，那么我们可以将 L 或 R 数组用输出数组来计算。先把输出数组当作 L 数组来计算，然后再动态构造 R 数组得到结果。让我们来看看基于这个思想的算法。

算法

        初始化 answer 数组，对于给定索引 i，answer[i] 代表的是 i 左侧所有数字的乘积。
        构造方式与之前相同，只是我们试图节省空间，先把 answer 作为方法一的 L 数组。
        这种方法的唯一变化就是我们没有构造 R 数组。而是用一个遍历来跟踪右边元素的乘积。并更新数组 answer[i]=answer[i]∗R。然后 R 更新为 R=R∗nums[i]，其中变量 R 表示的就是索引右侧数字的乘积。

三. 解题算法：

3.1 左右乘积列表算法

3.1.1 基于Python编写

class Solution:
    def productExceptSelf(self, nums: List[int]) -> List[int]:
        ### 方法一
        n = len(nums)
        # L, R 分别用来存储索引 i 左右两边元素的乘积
        L = [0 for _ in range(n)]
        R = [0 for _ in range(n)]
        answer = [0 for _ in range(n)]
        # 计算数组 L
        L[0] = 1
        for i in range(1, n):
            L[i] = L[i - 1] * nums[i - 1]
        # 计算数组 R
        R[n - 1] = 1 
        for j in reversed(range(n - 1)):
            R[j] = R[j + 1] * nums[j + 1]
        # 计算数组 answer
        for k in range(n):
            answer[k] = L[k] * R[k]
        return answer

3.1.2 基于Java编写

class Solution {
    public int[] productExceptSelf(int[] nums) {
        int n = nums.length;
        int L[] = new int[n];
        int R[] = new int[n];
        int answer[] = new int[n];
        L[0] = 1;
        for (int i = 1; i < n; i++) {
            L[i] = L[i - 1] * nums[i - 1];
        }
        R[n - 1] = 1;
        for (int j = n - 2; j >= 0; j--) {
            R[j] = R[j + 1] * nums[j + 1];
        }
        for (int k = 0; k < n; k++) {
            answer[k] = L[k] * R[k];
        }
        return answer;
    }
}

3.2 空间复杂度 O(1) 算法

3.2.1 基于Python编写

class Solution:
    def productExceptSelf(self, nums: List[int]) -> List[int]:
        ### 方法二
        n = len(nums)
        answer, R= [0] * n, [0] * n
        # 先创建的 answer 数组相当于方法一的 L数组
        answer[0] = 1
        for i in range(1, n):
            answer[i] = answer[i - 1] * nums[i - 1]
        
        R = 1
        # 更新 answer
        for j in reversed(range(n - 1)):
            R = R * nums[j + 1]
            answer[j] = answer[j] * R
        return answer

3.2.2 基于Java编写

class Solution {
    public int[] productExceptSelf(int[] nums) {
        int n = nums.length;
        int[] answer = new int[n];
        answer[0] = 1;
        for (int i = 1; i < n; i++) {
            answer[i] = answer[i - 1] * nums[i - 1];
        }
        int R = 1;
        for (int j = n-2; j >= 0; j--) {
            R = R * nums[j + 1];
            answer[j] = answer[j] * R;
        }
        return answer;
    }
}

版权声明

本文部分解题思路和代码实现参考自 LeetCode 官方题解《 238.除自身以外数组的乘积》(https://leetcode.cn/problems/product-of-array-except-self/solutions/272369/chu-zi-shen-yi-wai-shu-zu-de-cheng-ji-by-leetcode-/），所有引用内容仅供学习交流使用。