给定一个整数数组，找到相邻元素中乘积最大的那一对，并返回该乘积（JavaScript）

---

在本题中，我们的任务是找到给定数组中相邻元素乘积最大的一对，并返回该乘积。我们需要借助 Javascript 的功能来实现这个问题。

给定问题的逻辑

在给定的问题陈述中，我们需要计算数组中最大元素的乘积，并将结果输出到控制台。我们将通过两种方法来实现这个问题：第一种是使用 Infinity，第二种是不使用 Infinity。Infinity 是一个全局对象，其值大于任何数字。如果我们使用负无穷大，则表示它是最小数字。在第二种方法中，我们将首先初始化前两个元素的乘积，并将其值与所有乘积进行比较，如果结果大于此乘积，则返回其值。

算法 - 使用 Infinity

步骤 1 − 在代码开头声明一个整数数组。

步骤 2 − 定义一个名为 findProduct 的函数，该函数以输入数组作为参数，并返回数组中最大元素的乘积。

步骤 3 − 我们初始化一个变量来存储最大元素和结果乘积。

步骤 4 − 我们开始一个 for 循环来遍历数组的每个元素，使用乘法运算符计算相邻元素的乘积。

步骤 5 − 如果上述步骤的结果乘积大于步骤 3 中定义的最大乘积，我们将使用新的乘积值更新其值。

步骤 6 − 最后，显示数组中最大元素的最大乘积的输出。

算法代码 - 使用 Infinity

const arr = [1, 2, 3, 4, 5];
//function to calculate the largest product of adjacent items
const findProduct = (arr = []) => {
   //variable to store largest product
   var largest = -Infinity;
   for(let i = 0; i < arr.length - 1; i++){
      const product = arr[i] * arr[i + 1];
      if(product > largest){
         largest = product;
      }
   }
   return largest;
};
console.log(findProduct(arr));

算法 - 不使用 Infinity

步骤 1 − 此步骤涉及创建一个数组，我们将从中计算两个相邻元素的最大乘积。

步骤 2 − 我们定义一个函数来确定数组中两个相邻元素的最大乘积。

步骤 3 − 我们通过计算前两个相邻元素的乘积来声明最大乘积值。

步骤 4 − 从初始化最大乘积的值和开始一个 for 循环开始。for 循环遍历数组，并使用乘法运算符计算相邻元素的乘积。如果两个相邻元素的乘积大于当前最大乘积值，我们将新的最大值添加到步骤 3 中定义的变量中。

步骤 5 − 最后，此步骤显示两个最大相邻元素的最大乘积。

算法代码 - 不使用 Infinity

const arr = [5, 6, 7, 8, 9];
//function to calculate the largest product
const findLargestProduct = (arr = []) => {
   let largestProduct = arr[0] * arr[1];
   for(let i = 1; i < arr.length - 1; i++){
      const product = arr[i] * arr[i + 1];
      if(product > largestProduct){
         largestProduct = product;
      }
   }
   return largestProduct;
};
console.log(findLargestProduct(arr));

复杂度

用于确定两个相邻元素的乘积的第一种方法的时间和空间复杂度分别为 O(n) 和 O(1)。

代码具有 O(n) 时间复杂度的原因为使用单个 for 循环计算输入数组中相邻元素的乘积。此外，代码的内存使用是恒定的，导致空间复杂度为 O(1)。

关于第二个代码：O(n^2) 和 O(n) 分别是时间和空间复杂度。

在第二个代码中，使用了两个 for 循环来计算给定数组中相邻元素的部分和。因此，两个循环都遍历了整个数组，所以此代码的时间复杂度为 O(n^2)，n 是输入数组的大小。代码还使用数组存储部分和，其空间复杂度为 O(n)。

结论

以上代码有效地找到了数组中任何相邻元素的最大乘积。我们可以看到第一种方法的时间复杂度为 O(n)，因此它比第二种方法（时间复杂度为 O(n^2)）更有效，后者效率较低。因此，总的来说，使用代码的时间和空间复杂度来优化算法性能是一个重要因素。