题目描述

题目：除自身以外数组的乘积

给定一个整数数组 nums，编写一个函数，该函数返回一个新数组，其中新数组的每个元素是原数组 nums 中除了该元素以外所有元素的乘积。

示例 1:

输入: nums = [1,2,3,4]
输出: [24,12,8,6]
解释:
n = 4
乘积对应为:
[2*3*4, 1*3*4, 1*2*4, 1*2*3] = [24,12,8,6]

示例 2:

输入: nums = [-1,1,0,-3,3]
输出: [0,0,9,0,0]
解释:
n = 5
乘积对应为:
[-1*1*0*-3*3, -1*0*-3*3, -1*1*0*3, -1*1*-3*3, -1*1*0*-3] = [0,0,9,0,0]
注意：由于数组中存在 0，因此乘积为 0。

PHP 示例代码

function productExceptSelf($nums) {
    $n = count($nums);
    $leftProduct = array_fill(0, $n, 1); // 左侧乘积数组，初始化为1
    $rightProduct = array_fill(0, $n, 1); // 右侧乘积数组，初始化为1

    // 计算左侧乘积
    for ($i = 1; $i < $n; $i++) {
        $leftProduct[$i] = $leftProduct[$i - 1] * $nums[$i - 1];
    }

    // 计算右侧乘积（从右向左）
    for ($i = $n - 2; $i >= 0; $i--) {
        $rightProduct[$i] = $rightProduct[$i + 1] * $nums[$i + 1];
    }

    // 合并左右乘积得到最终结果
    $result = array();
    for ($i = 0; $i < $n; $i++) {
        $result[] = $leftProduct[$i] * $rightProduct[$i];
    }

    return $result;
}

Python 示例代码

def productExceptSelf(nums):
    n = len(nums)
    left_product = [1] * n  # 左侧乘积数组，初始化为1
    right_product = [1] * n  # 右侧乘积数组，初始化为1

    # 计算左侧乘积
    for i in range(1, n):
        left_product[i] = left_product[i - 1] * nums[i - 1]

    # 计算右侧乘积（从右向左）
    for i in range(n - 2, -1, -1):
        right_product[i] = right_product[i + 1] * nums[i + 1]

    # 合并左右乘积得到最终结果
    return [left * right for left, right in zip(left_product, right_product)]

JavaScript 示例代码

function productExceptSelf(nums) {
    const n = nums.length;
    const leftProduct = new Array(n).fill(1); // 左侧乘积数组，初始化为1
    const rightProduct = new Array(n).fill(1); // 右侧乘积数组，初始化为1

    // 计算左侧乘积
    for (let i = 1; i < n; i++) {
        leftProduct[i] = leftProduct[i - 1] * nums[i - 1];
    }

    // 计算右侧乘积（从右向左）
    for (let i = n - 2; i >= 0; i--) {
        rightProduct[i] = rightProduct[i + 1] * nums[i + 1];
    }

    // 合并左右乘积得到最终结果
    const result = [];
    for (let i = 0; i < n; i++) {
        result.push(leftProduct[i] * rightProduct[i]);
    }

    return result;
}

这些示例代码均使用了空间换时间的策略，通过分别计算每个元素左侧和右侧的乘积，然后合并得到最终结果。这种方法的时间复杂度为 O(n)，空间复杂度也为 O(n)。