除自身以外数组的乘积（c语言详解）

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

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

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

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

提示：

 2 <= nums.lengh <= 10^5

-30 <= nums[i] <= 30

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

示例 1:

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

输出：[ 24，12，8，6 ]

示例 2:

输入：nums=[ -1，-1，0，-3，3 ]

输出：[ 0，0，9，0，0 ]

解题思路：

定义两个数组（前缀乘积数组与后缀乘积数组），前缀数组为：left [ ] ，后缀数组：right [ ] ;

left [ i ] 里存 nums [ i ] 前面的乘积和，righ[ i ] 里存 nums [ i ] 后面的乘积和，(为空时存1)；

创建一个动态内存变量 int* ret=(int*)malloc(sizeof(int)*numsSize);

然后ret [ i ]=left [ i ] * right [ i ]，存储后返回；

思路实现：

因为数组元素 ：2 <= nums.lengh <= 10^5

所以前缀和后缀数组申请的数组大小都是10^5;

int left[100000]={0};
int right[100000]={0};

然后就是遍历求前缀乘积数组的各项值：

    //前缀乘积和
    for(i=0;i<numsSize;i++)
    {
        if(i==0)
        {
            left[i]=1;
        }
        else
        {
            left[i]=left[i-1]*nums[i-1];
        }
    }

解析：

这里呢用数组 nums [ 1，2，3，4，5，6 ] 来举例； 

此时，left [ 0 ] =1，然后 left [ 1 ] = left [ 0 ] * nums [ 0 ]  相当于 left [ 1 ] = nums [ 0 ] ;

left [ 2 ] = left [ 1 ] * nums [ 1 ]  相当于 left [ 2 ] = nums [ 0 ] * nums [ 1 ] ;

left [ 3 ] = left [ 2 ] * nums [ 2 ]  相当于 left [ 3 ] = nums [ 0 ] * nums [ 1 ] * nums [ 2 ] ;

。。。。。。

left [ 5 ] = left [ 4 ] * nums [ 4 ]  相当于 left [ 5 ] = nums [ 0 ] * nums [ 1 ] * nums [ 2 ] * nums [ 3 ] * nums [ 4 ] ；

想必大家也已经找到其中的规律了；

然后就是遍历求后缀乘积数组的各项值：

   //后缀乘积和
    for(i=numsSize-1;i>=0;i--)
    {
        if(i==numsSize-1)
        {
            right[i]=1;
        }
        else
        {
            right[i]=right[i+1]*nums[i+1];
        }
    }

解析：

同理：nums [ 1，2，3，4，5，6 ]

left [ 5 ] =1，然后 left [ 4 ] = left [ 5 ] * nums [ 5 ]  相当于 left [ 4 ] = nums [ 5 ] ;

left [ 3 ] = left [ 4 ] * nums [ 4 ]  相当于 left [ 3 ] = nums [ 4 ] * nums [ 5 ] ;

left [ 2 ] = left [ 3 ] * nums [ 3 ]  相当于 left [ 2 ] = nums [ 3 ] * nums [ 4 ] * nums [ 5 ] ;

。。。。。。

left [ 0 ] = left [ 1 ] * nums [ 1 ]  相当于 left [ 0 ] = nums [ 1 ] * nums [ 2 ] * nums [ 3 ] * nums [ 4 ] * nums [ 5 ] ；

然后就是给返回值（* returnSize）赋值，以及创建动态内（ret），以及给其赋值再返回；

    * returnSize=numsSize;
    int* ret=(int*)malloc(4*numsSize);
    //给返回指针赋值
    for(i=0;i<numsSize;i++)
    {
        ret[i]=left[i]*right[i];
    }

时间复杂度为（O(N) ) ；

这就是这道题目的基本思路，下面是程序源代码：

int* productExceptSelf(int* nums, int numsSize, int* returnSize){
    int i=0;
    int left[100000]={0};
    int right[100000]={0};
    //前缀乘积和
    for(i=0;i<numsSize;i++)
    {
        if(i==0)
        {
            left[i]=1;
        }
        else
        {
            left[i]=left[i-1]*nums[i-1];
        }
    }
    //后缀乘积和
    for(i=numsSize-1;i>=0;i--)
    {
        if(i==numsSize-1)
        {
            right[i]=1;
        }
        else
        {
            right[i]=right[i+1]*nums[i+1];
        }
    }
    * returnSize=numsSize;
    int* ret=(int*)malloc(4*numsSize);
    //给返回指针赋值
    for(i=0;i<numsSize;i++)
    {
        ret[i]=left[i]*right[i];
    }
    return ret;
}

如有不足欢迎来补充交流！

完结。。。

---