当前位置：首页 > news >正文

力扣经典算法篇-11-除自身以外数组的乘积（总乘积求除法，左右乘积法）

news 2025/7/17 7:25:02

1、题干

给你一个整数数组 nums，返回数组 answer ，其中 answer[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积。
题目数据保证数组 nums之中任意元素的全部前缀元素和后缀的乘积都在 32 位整数范围内。

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

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

示例 2:
输入: nums = [-1,1,0,-3,3]
输出: [0,0,9,0,0]

提示：
2 <= nums.length <= 105
-30 <= nums[i] <= 30
输入保证数组 answer[i] 在 32 位整数范围内

进阶：
你可以在 O(1) 的额外空间复杂度内完成这个题目吗？（出于对空间复杂度分析的目的，输出数组不被视为额外空间。）

2、解题

方法一：暴力求解法

定义额外的数组依次遍历进行赋值，遇到相同下标时跳过。

public static int[] productExceptSelf(int[] nums) {
        int[] result = new int[nums.length];
        int temp;
        for (int i = 0; i < nums.length; i++) {
            temp = 1;
            for (int j = 0; j < nums.length; j++) {
                if (j == i) {
                    continue;
                }
                temp = temp * nums[j];
                if (temp == 0) {
                    break;
                }
            }
            result[i] = temp;
        }
        return result;
    }

方法二：总乘积求除法

先求出所有元素的乘积，之后除以当前元素值就是其余元素的乘积值。

注意：值为0的元素造成干扰，所以需要预先判断元素为0的数量和非0元素的乘积。
大于1时，结果必定都是0。
等于1时，元素值为0时，为非0元素的乘积；不为0时，都是0。
小于0时，即没有0值的元素，直接用总乘积除以当前元素获取。

public static int[] productExceptSelf(int[] nums) {
        int[] result = new int[nums.length];

        List<Integer> zeroList = new ArrayList<>();
        int all = 1;
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] == 0) {
                zeroList.add(i);
            } else {
                all *= nums[i];
            }
        }
        if (zeroList.size() > 1) {
            return result;
        } else if (zeroList.size() == 1) {
            for (int i = 0; i < nums.length; i++) {
                if (nums[i] == 0) {
                    result[i] = all;
                } else {
                    result[i] = 0;
                }
            }
        } else {
            for (int i = 0; i < nums.length; i++) {
                result[i] = all / nums[i];
            }
        }

        return result;
    }

方法三：左右乘积法

定义两个额外的数组，左数组和右数组。
左数组保存从左遍历，从头开始到前一个元素的结果。右数组则保存从右遍历，元素的乘积。
具体解释：
左数组：

计算第0个元素，左边没有元素，默认1；
计算第1个元素，左边只有1个元素，为原始数组第0个元素的值；
计算第2个元素，左边包含第0和第1个两个元素，为这两个元素的乘积，之后以此类推

右数组和左数组同理，方向相反。

   public static int[] productExceptSelf(int[] nums) {
        int[] result = new int[nums.length];

        int[] left = new int[nums.length];      // 从左遍历，存储每个元素左边元素的乘积
        int[] right = new int[nums.length];       // 从右遍历，存储每个元素右边元素的乘积

        // 因为第0个元素左边没有元素，默认1。第1个元素，则为第0个元素的值，第2个元素为第0和第1个元素的乘积，以此类推
        left[0] = 1;
        for (int i = 1; i < nums.length; i++) {
            left[i] = left[i - 1] * nums[i - 1];
        }
		
		// 右数组
        right[nums.length - 1] = 1;
        for (int i = nums.length - 2; i >= 0; i--) {
            right[i] = right[i + 1] * nums[i + 1];
        }

        // 结果数组
        for (int i = 0; i < nums.length; i++) {
            result[i] = left[i] * right[i];
        }

        return result;
    }

方法四：左右乘积法优化

方法三的优化，左数组同理生成，右数组在遍历生成的同时就可以计算结果元素，并保存到结果中。

 public static int[] productExceptSelf(int[] nums) {
        int[] left = new int[nums.length];      // 从左遍历，存储每个元素左边元素的乘积

        // 因为第0个元素左边没有元素，默认1。第1个元素，则为第0个元素的值，第2个元素为第0和第1个元素的乘积，以此类推
        left[0] = 1;
        for (int i = 1; i < nums.length; i++) {
            left[i] = left[i - 1] * nums[i - 1];
        }

        int right = 1;
        for (int i = nums.length - 1; i >= 0; i--) {
            left[i] = left[i] * right;
            right = right * nums[i];
        }

        return left;
    }