leetcode238:除自身以外数组的乘积

文章目录

  • 1.使用除法(违背题意)
  • 2.左右乘积列表
  • 3.空间复杂度为O(1)的方法

在leetcode上刷到了这一题,一开始并没有想到好的解题思路,写篇博客再来梳理一下吧。
在这里插入图片描述

leetcode238:除自身以外数组的乘积_第1张图片
题目要求:

  • 不使用除法
  • 在O(n)时间复杂度内

1.使用除法(违背题意)

该方法分以下几步:

  1. 先遍历数组,求数组所有元素的乘积sum
  2. 再遍历一遍数组,使用sum除以该下标对应的元素,将结果放在answer数组中

leetcode238:除自身以外数组的乘积_第2张图片

#include
#include
int* productExceptSelf(int* nums, int numsSize, int* returnSize) {
    int* answer = (int*)calloc(numsSize, sizeof(int));
    *returnSize = numsSize;
    int sum = 1;
    for (int i = 0; i < numsSize; i++)
    {
        sum *= nums[i]; //求所有元素的乘积
    }
    for (int i = 0; i < numsSize; i++)
    {
        answer[i] = sum / nums[i];
    }
    return answer;
}

int main()
{
	int arr[] = { 1,2,3,4 };
	int sz = sizeof(arr) / sizeof(arr[0]);
    int count = 0;
    int* ret = productExceptSelf(arr, sz, &count);
    for (int i = 0; i < count; i++)
    {
        printf("%d", *(ret + i));
        if (i != count - 1)
        {
            printf(",");
        }
    }
    free(ret);
    ret = NULL;
	return 0;
}

2.左右乘积列表

相较于第一种方法,我们不必将所有数字的乘积除以给定索引处的数字得到相应的答案,而是利用索引左侧所有数字的乘积和右侧所有数字的乘积(即前缀与后缀)相乘得到答案。这也是题目中暗示我们的
leetcode238:除自身以外数组的乘积_第3张图片

该方法分以下几步:

  • 初始化两个空数组 Left 和 Right。对于给定下标 i,Left[i] 代表的是 i 左侧所有数字的乘积,Right[i] 代表的是 i 右侧所有数字的乘积。
  • 对于数组 Left,Left[0] 应该是 1,因为第一个元素的左边没有元素。对于数组 Right,Right[length-1] 应为 1,因为最后一个元素右侧没有元素。(length 指的是输入数组的大小)
  • 对于其它的元素,Left[i] = Left[i-1] * nums[i-1] (i从1开始 i++)

leetcode238:除自身以外数组的乘积_第4张图片

  • 对于其它的元素,Right[i] = Right[i+1] * nums[i+1] (i从length-2开始 i–)

leetcode238:除自身以外数组的乘积_第5张图片

  • 当 Left 和 Right 数组填充完成,我们只需要在输入数组上迭代:answer[i] = Left[i] * Righti]
#include
#include
int* productExceptSelf(int* nums, int numsSize, int* returnSize) {
    int* answer = (int*)calloc(numsSize, sizeof(int));
    *returnSize = numsSize;
    int Left[numsSize];
    int Right[numsSize];
    Left[0] = 1;
    Right[3] = 1;
    for (int i = 1; i < numsSize; i++)
    {
        Left[i] = Left[i - 1] * nums[i - 1];
    }
    for (int i = 2; i >= 0; i--)
    {
        Right[i] = Right[i + 1] * nums[i + 1];
    }
    for (int i = 0; i < numsSize; i++)
    {
        answer[i] = Left[i] * Right[i];
    }
    return answer;
}

int main()
{
	int arr[] = { 1,2,3,4 };
	int sz = sizeof(arr) / sizeof(arr[0]);
    int count = 0;
    int* ret = productExceptSelf(arr, sz, &count);
    for (int i = 0; i < count; i++)
    {
        printf("%d", *(ret + i));
        if (i != count - 1)
        {
            printf(",");
        }
    }
    free(ret);
    ret = NULL;
	return 0;
}

复杂度分析:

  • 时间复杂度:O(N),其中 N 指的是数组 nums 的大小。预处理 Left 和 Right 数组以及最后的遍历计算都是 O(N)的时间复杂度。
  • 空间复杂度:O(N),其中 N 指的是数组 nums 的大小。使用了 Left 和 Right 数组去构造答案,Left 和 Right 数组的长度为数组 nums 的大小。

3.空间复杂度为O(1)的方法

由于输出数组不算在空间复杂度内,而且我们的answer数组只有最后才被用到,所以我们可以先将 Left 或 Right 数组用answer数组来计算。
该方法分为以下几步:

  • 先把answer数组当作 Left数组来计算,然后再动态构造 Right 数组得到结果。这样我们就节省了两个数组,空间复杂度就为O(1)了。
  • 动态构造Right数组我们只使用一个变量R就可以了,该变量初始化为1。R * nums[i] 即可得到最终的结果.

leetcode238:除自身以外数组的乘积_第6张图片

#include
#include
int* productExceptSelf(int* nums, int numsSize, int* returnSize) {
    int* answer = (int*)calloc(numsSize, sizeof(int));
    *returnSize = numsSize;
    int left[numsSize];
    int right[numsSize];
    answer[0] = 1;
    int R = 1;
    //先求前缀之积
    for (int i = 1; i < numsSize; i++)
    {
        answer[i] = answer[i - 1] * nums[i - 1];
    }
    //求后缀之积与answer
    for (int i = numsSize - 1; i >= 0; i--)
    {
        // 对于下标 i,左边的乘积为 answer[i],右边的乘积为 R
        answer[i] = answer[i] * R;
        // R 需要包含右边所有的乘积,所以计算下一个结果时需要将当前值乘到 R 上
        R *= nums[i];
    }
    return answer;
}

int main()
{
	int arr[] = { 1,2,3,4 };
	int sz = sizeof(arr) / sizeof(arr[0]);
    int count = 0;
    int* ret = productExceptSelf(arr, sz, &count);
    for (int i = 0; i < count; i++)
    {
        printf("%d", *(ret + i));
        if (i != count - 1)
        {
            printf(",");
        }
    }
    free(ret);
    ret = NULL;
	return 0;
}

复杂度分析

  • 时间复杂度:O(N),其中 NNN 指的是数组 nums 的大小。分析与方法一相同。
  • 空间复杂度:O(1),输出数组不算进空间复杂度中,因此我们只需要常数的空间存放变量。

目前想到的方法就这些,后续想到会补充。

你可能感兴趣的:(leetcode,算法,leetcode,刷题)