leetcode hot100【LeetCode 238.除自身以外数组的乘积】java实现

LeetCode 238.除自身以外数组的乘积

题目描述

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

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

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

示例 1:

输入: nums = [1,2,3,4]
输出: [24,12,8,6]

示例 2:

输入: nums = [0,2,3,4]
输出: [0,12,0,0]

Java 实现代码

解法一：

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

    }
}

解法二：

public 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 rightProduct = 1;
        for (int i = n - 1; i >= 0; i--) {
            answer[i] *= rightProduct;
            rightProduct *= nums[i];
        }
        
        return answer;
    }
}

解题思路

1.前缀乘积和后缀乘积：
使用两个数组 leftProduct 和 rightProduct 分别存储每个元素左侧所有元素的乘积和右侧所有元素的乘积。
最终的结果 answer[i] 等于 leftProduct[i] * rightProduct[i]。
2.优化：为了节省空间，可以在一次遍历中用一个变量维护左侧乘积，另一次遍历中用另一个变量维护右侧乘积，从而实现 O(1) 额外空间（不计算输出数组）

复杂度分析

• 时间复杂度：O(n)，其中 n 是数组的长度。我们只需要遍历数组两次。
• 空间复杂度：O(1)。我们只使用了常量级别的额外空间。

执行过程示例

输入 nums = [1, 2, 3, 4]：

1. 左侧乘积（填充 answer）：

   • 初始：answer = [1, _, _, _]
   • i = 1: answer[1] = answer[0] * nums[0] = 1 * 1 = 1，answer = [1, 1, _, _]
   • i = 2: answer[2] = answer[1] * nums[1] = 1 * 2 = 2，answer = [1, 1, 2, _]
   • i = 3: answer[3] = answer[2] * nums[2] = 2 * 3 = 6，answer = [1, 1, 2, 6]

2. 右侧乘积：

   • 初始化 rightProduct = 1
   • i = 3: answer[3] = answer[3] * rightProduct = 6 * 1 = 6，更新 rightProduct = 1 * nums[3] = 4
   • i = 2: answer[2] = answer[2] * rightProduct = 2 * 4 = 8，更新 rightProduct = 4 * nums[2] = 12
   • i = 1: answer[1] = answer[1] * rightProduct = 1 * 12 = 12，更新 rightProduct = 12 * nums[1] = 24
   • i = 0: answer[0] = answer[0] * rightProduct = 1 * 24 = 24

最终结果：[24, 12, 8, 6]