除自身以外数组的乘积

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param nums int整型一维数组 
     * @return int整型一维数组
     */
    public int[] timesExceptSelf (int[] nums) {
        // write code here
        int[] res = new int[nums.length];
        res[0] = 1;
        for(int i = 1; i < nums.length; i++){
            res[i] = res[i - 1] * nums[i - 1];
        }
        int temp = 1;
        for(int i = nums.length - 1; i >=0; i--){
            res[i] = temp * res[i];
            temp = temp * nums[i];
        }
        return res;
    }
}

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param nums int整型vector 
     * @return int整型vector
     */
    vector<int> timesExceptSelf(vector<int>& nums) {
        // write code here
        int n = nums.size();
        vector<int> res(n, 1);
        vector<int> res2(n, 1);
        // 保存从右往左的乘积 加入输入是 1 2 3 4
        // 对应的输出就是 24 12 4 1
        for(int i=n-2; i>=0; i--)
        {
            res[i] = res[i+1] * nums[i+1];
        }
        // 保存的是从左往右的乘积 假如输入的是 1 2 3 4
        // 输出是 1 1 2 6
        for(int i=1; i<n; i++)
        {
            res2[i] = res2[i-1] * nums[i-1];
        }
        // 从左往右的值 乘上 从右往左 就是最后的输出结果
        for(int i=0; i<n; i++)
        {
            res[i] = res[i] * res2[i];
        }
        return res;
    }
};

#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param nums int整型一维数组 
# @return int整型一维数组
#
class Solution:
    def timesExceptSelf(self , nums: List[int]) -> List[int]:
        # write code here
        dp_l = nums.copy()
        for i in range(1, len(dp_l)):
            dp_l[i] = dp_l[i-1] * nums[i]

        dp_r = nums.copy()
        for i in range(len(dp_r)-1 -1, -1, -1):
            dp_r[i] = dp_r[i + 1] * nums[i]

        res = nums.copy()
        res[0] = dp_r[1]
        res[-1] = dp_l[-2]
        for i in range(1, len(nums)-1):
            res[i] = dp_l[i-1] * dp_r[i + 1]
        return res

#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param nums int整型一维数组 
# @return int整型一维数组
#
class Solution:
    def timesExceptSelf(self , nums: List[int]) -> List[int]:
        reslist = []
        pro = 1
        count = nums.count(0) 

        for i in nums:
            if i != 0:
                pro *= i

        if count == 0:
            for i in nums:
                reslist.append(pro//i)
        elif count == 1:
            for i in nums:
                if i != 0:
                    reslist.append(0)
                elif i == 0:
                    reslist.append(pro)
        else:
            for i in nums:
                reslist.append(0)

        
        return reslist
        # write code here

package main

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param nums int整型一维数组 
 * @return int整型一维数组
*/
func timesExceptSelf( nums []int ) []int {
    pre:=1
    ans:=make([]int,len(nums))
    for i:=0;i<len(nums);i++{
        ans[i]=pre
        pre*=nums[i]
    }
    pre=1
    for i:=len(nums)-1;i>=0;i--{
        ans[i]*=pre
        pre*=nums[i]
    }
    return ans
}

空间复杂度为O(1),时间复杂度为O(n)
实际上返回数组是可以重复利用的，不必用两个数组

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param nums int整型vector 
     * @return int整型vector
     */
    vector timesExceptSelf(vector& nums) {
        // write code here
        int n = nums.size();
        if(nums.size() < 2)
            return nums;

        vector res;
        res.push_back(1);
        int temp;

        for(int i = 1;i < n;++i)
        {
            temp = res[i-1] * nums[i-1];
            res.push_back(temp);
        }

        temp = nums[n-1];
        for(int i = n-2;i > 0;--i)
        {
            res[i] *= temp;
            temp *= nums[i];
        }

        temp = 1;
        for(int i = 1;i < n;++i)
        {
            temp *= nums[i];
        }
        res[0] = temp;

        return res;
    }
};

public int[] timesExceptSelf (int[] nums) {
        int n=nums.length;
        int preTime[]=new int[n];
        int postTime[]=new int[n];
        postTime[n-1]=1;
        preTime[0]=1;
        int result[]=new int[n];
        //倒着各元素的乘积
        for(int i=n-2;i>=0;i--){
            postTime[i]=postTime[i+1]*nums[i+1];
        }
        //顺着各元素的乘积
        for(int i=1;i<n;i++){
            preTime[i]=preTime[i-1]*nums[i-1];
            result[i]=preTime[i]*postTime[i];
        }
        result[0]=postTime[0];
        return result;
    }