4月30天leetcode训练-Day15

Day 15 - Product of Array Except Self

问题描述：

给定一个由n个整数组成的数组，其中n> 1，则返回一个数组输出，使得output [i]等于除nums [i]之外的所有nums元素的乘积。

Example:

Example:

Input:  [1,2,3,4]
Output: [24,12,8,6]

解法一：

不考虑时间复杂度的话，通过递归暴力破解，设置递归辅助函数，传入数组和开始，结束位置。开始遍历，当前元素对应的输出为当前元素之前的元素乘积和之后的元素乘积，所以传入辅助函数的开始和结束位置分别为（数组开始，当前位置）；（下一个位置，数组结束），如果开始节点和结束节点相同说明当前为第一个元素或者为最后一个元素，此时返回1.

class Solution:
    def productExceptSelf(self, nums: List[int]) -> List[int]:
        output = [0] * len(nums)
        for i in range(len(nums)):
            output[i] = self.helper(nums,0,i) * self.helper(nums,i + 1,len(nums))
        return output
    def helper(self,nums,start,end):
        if start >= end:
            return 1
        result = 1
        for i in range(start,end):
            result = result * nums[i]
        return result

这种解法就属于简单直接的暴力破解，时间复杂度肯定要高的多，leetcode也肯定不能通过了。

解法二：

这种想法是在写这篇博客的时候想到的，直接先遍历一遍获得所有元素的乘积，然后再遍历一遍，遇到的元素对应的输出为数组乘积除以当前元素。这样时间复杂度为O（n）.但是这道题目要求好像不能用除法。。。。所以代码我也不写了，只是提出一种这样的思路。

解法三：

通过两个数组分别存储当前元素的前面元素乘积，和后面元素的乘积，然后两个乘积即可。通过三次遍历，前后前。

class Solution:
    def productExceptSelf(self, nums: List[int]) -> List[int]:
        left = [0] * len(nums)
        right = [0] * len(nums)
        left[0] = 1
        right[len(nums) - 1] = 1
        for i in range(1,len(nums)):
            left[i] = nums[i-1] * left[i -1]
        print(right)
        for i in range(len(nums) -2, -1,-1):
            right[i] = right[i + 1] * nums[i + 1]
        result = [0] * len(nums)
        for i in range(len(nums)):
            result[i] = left[i]*right[i]
        return result

时间复杂度为O（n）,但是题目要求用恒定的时间复杂度来解决。。。这个意思我也不太清楚是啥意思，但是上面的空间复杂度可以降低一点，可以只用一个输出数组表示。

解法四：

只用最后的result数组表示输出，先前序遍历，存储每个元素前面的元素乘积，然后再后续遍历一次，设置一个临时变量表示从后面开始的乘积数。

class Solution:
    def productExceptSelf(self, nums: List[int]) -> List[int]:
        result,right = [1] * len(nums),1
        for i in range(1,len(nums)):
            result[i] = nums[i-1] * result[i -1]
        for i in range(len(nums) -1, -1,-1):
            result[i] = right * result[i]
            right *= nums[i]
        return result

时间复杂度和上面的方法一样都是O（n）但是空间复杂度能稍微降低一些。