学习记录：js算法（七十二）：最大子数组和

news2024/10/23 18:39:38

文章目录

- 最大子数组和
- - 思路一
  - 思路二
  - 思路三
  - 思路四

最大子数组和

给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
子数组 是数组中的一个连续部分。

示例 1：
输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。

示例 2：
输入：nums = [1]
输出：1

示例 3：
输入：nums = [5,4,-1,7,8]
输出：23

思路一

function maxSubArray(nums) {
  let maxSoFar = nums[0];
  let maxEndingHere = nums[0];

  for (let i = 1; i < nums.length; i++) {
    maxEndingHere = Math.max(nums[i], maxEndingHere + nums[i]);
    maxSoFar = Math.max(maxSoFar, maxEndingHere);
  }

  return maxSoFar;
}

讲解
贪心算法在这里指的是在每一步都做出局部最优的选择，希望这样能够得到全局最优解。在最大子数组和问题中，这个局部最优的选择就是在当前位置决定是否开始一个新的子数组，还是继续扩展当前的子数组。
贪心算法的实现如下：

初始化两个变量：maxSoFar 用于存储目前为止发现的最大子数组和，maxEndingHere 用于存储以当前元素结尾的最大子数组和。这两个变量都初始化为数组的第一个元素。
从数组的第二个元素开始遍历数组。
对于每一个元素，有两种选择：
○ 要么添加当前元素到前面的子数组中，即 maxEndingHere + nums[i] 。
○ 要么开始一个新的子数组，即 nums[i] 。
选择这两种情况中的较大者作为新的 maxEndingHere 。
更新 maxSoFar，如果 maxEndingHere 大于 maxSoFar，则更新 maxSoFar。
继续遍历直到数组结束，最后 maxSoFar 即为所求的最大子数组和。

思路二

function maxCrossingSum(nums, left, mid, right) {
    let sum = 0;
    let leftSum = -Infinity;
    for (let i = mid; i >= left; i--) {
        sum += nums[i];
        leftSum = Math.max(leftSum, sum);
    }
    sum = 0;
    let rightSum = -Infinity;
    for (let i = mid + 1; i <= right; i++) {
        sum += nums[i];
        rightSum = Math.max(rightSum, sum);
    }
    return leftSum + rightSum;
}
function maxSubArrayHelper(nums, left, right) {
    if (left === right) {
        return nums[left];
    }
    const mid = Math.floor((left + right) / 2);
    const leftMax = maxSubArrayHelper(nums, left, mid);
    const rightMax = maxSubArrayHelper(nums, mid + 1, right);
    const crossMax = maxCrossingSum(nums, left, mid, right);
    return Math.max(leftMax, rightMax, crossMax);
}
function maxSubArray(nums) {
    return maxSubArrayHelper(nums, 0, nums.length - 1);
}

讲解

maxCrossingSum 函数：计算跨越中间点的最大子数组和
初始化 sum 为 0，leftSum 为负无穷（-Infinity），用于记录左半部分的最大和。
从中间点 mid 向左遍历，累加 sum，并更新 leftSum 为当前的最大值。
重置 sum 为 0，初始化 rightSum 为负无穷，用于记录右半部分的最大和。
从 mid + 1 向右遍历，累加 sum ，并更新 rightSum 为当前的最大值。
返回 leftSum 和 rightSum 的和，即跨越中间点的最大子数组和。

maxSubArrayHelper 函数：递归实现，负责将数组分割并计算最大子数组和
如果 left 等于 right，表示当前子数组只有一个元素，直接返回这个元素。
计算中间索引 mid。
递归调用 maxSubArrayHelper 计算左半部分的最大子数组和 leftMax。
递归调用 maxSubArrayHelper 计算右半部分的最大子数组和 rightMax。
调用 maxCrossingSum 计算跨越中间的最大子数组和 crossMax。
返回 leftMax、rightMax 和 crossMax 中的最大值。

maxSubArray 函数：初始化递归过程。
调用 maxSubArrayHelper，传入整个数组的左右边界**（0 到 nums.length - 1）**，返回最大子数组和。

思路三

 var maxSubArray = function (nums) {
    let maxSum = -Infinity;
    for (let i = 0; i < nums.length; i++) {
        let currentSum = 0;
        for (let j = i; j < nums.length; j++) {
            currentSum += nums[j];
            maxSum = Math.max(maxSum, currentSum);
        }
    }
    return maxSum;
};

讲解

初始化变量: 创建一个变量 maxSum，初始值为负无穷，用于记录找到的最大子数组和。
外层循环: 遍历数组的每一个元素，i 表示当前子数组的起始索引。
初始化当前和: 在每次外层循环开始时，初始化 currentSum 为 0，用于累加当前子数组的和。
内层循环: 从当前的起始索引 i 开始，遍历到数组的末尾，j 表示当前子数组的结束索引。
更新当前和: 将当前元素加入到 currentSum 中，更新当前子数组的和。
更新最大和: 使用 Math.max 比较 maxSum 和 currentSum，更新 maxSum 为较大者。
返回结果: 返回找到的最大子数组和 maxSum。

思路四

var maxSubArray = function (nums) {
 const prefixSum = new Array(nums.length + 1).fill(0);
    let maxSum = -Infinity;
    for (let i = 0; i < nums.length; i++) {
        prefixSum[i + 1] = prefixSum[i] + nums[i];
    }
    for (let i = 0; i < nums.length; i++) {
        for (let j = i; j < nums.length; j++) {
            const currentSum = prefixSum[j + 1] - prefixSum[i];
            maxSum = Math.max(maxSum, currentSum);
        }
    }
    return maxSum;
};

讲解

初始化前缀和数组: 创建一个前缀和数组，长度为输入数组长度加一，初始值全为0。
计算前缀和: 遍历输入数组，填充前缀和数组，使得每个位置存储从数组开始到当前位置的元素和。
初始化最大和: 设置一个变量 maxSum，初始值为负无穷，用于记录最大子数组和。
计算子数组和: 使用双重循环遍历所有可能的子数组，通过前缀和数组计算每个子数组的和，并更新 maxSum。
返回结果: 返回计算得到的最大子数组和。