最大子数组（Kadane 的算法方法）答案

【问题标题】：Maximum Subarray (Kadane's algorithm approach)最大子数组（Kadane 的算法方法）
【发布时间】：2018-03-27 22:36:58
【问题描述】：

https://leetcode.com/problems/maximum-subarray/description/

输入测试用例：

[-2,1,-3,4,-1,2,1,-5,4]
[-2, -1]
[-2, 1]
[1]
[1, 2]

     function maxSubarray(array) {
          
            var currentMax = array[0];
            var max = array[0];
          
            for (var i = 0; i < array.length; i++) {
              // Compare 0 and currentMax + array[i]
              // IF it is less than 0, it is going to be 0 (Reset)
              //    it is more than 0, it will be currentMax + next element
              currentMax = Math.max(array[i], currentMax + array[i]);
            
              // Compare max or currentMax value, pick up one.
              max = Math.max(max, currentMax);
              
            }
          
            // Return max at the end of loop
            return max;
        }
    
    console.log(maxSubarray([-2,1,-3,4,-1,2,1,-5,4])) // === 6
    console.log(maxSubarray([-2, -1])) // === -1
    console.log(maxSubarray([-2,1])) // === 1
    console.log(maxSubarray([1])) // === 1
    console.log(maxSubarray([1, 2])) // === 3

我想通过 Input: [-2, -1] 这个案例，所以我将 var currentMax = 0; 和 var max = 0; 修改为当前代码。

显然，Kadane 的算法需要包含至少一个正数，这样可能无法解决第二种情况。

是否可以通过使用 Kadane 的算法来解决所有这些测试用例，还是我需要以其他方式实现？

谢谢！

【问题讨论】：

标签： javascript algorithm

【解决方案1】：

最大和连续子数组.

这是我的解决方案，用于在总和最大的一维数字数组中找到连续子数组的总和。

我在没有遵循任何算法的情况下编写了这段代码。

function lrgSumContiArr(arr) {
  function getSum(startIndex, endIdex){
    return arr.slice(startIndex, endIdex).reduce((acc, cur) => acc + cur);
  }
  const lrgSumArrOfSubArr = arr.map((item, index) =>{
    let largeSum = Number.NEGATIVE_INFINITY;
    for(let i=index; i<arr.length; i++) {
        let subArrSum = getSum(index,i+1);
        if( subArrSum > largeSum) {
        largeSum = subArrSum;
      }
    }
    return largeSum;
  });
  /* const lrgSumOfSubArr = lrgSumArrOfSubArr.reduce((acc, cur) => {
    if (acc > cur){
      return acc;
    } else {
      return cur;
    }
  });
  return lrgSumOfSubArr; */
  return Math.max.apply(null,lrgSumArrOfSubArr);
}
lrgSumContiArr([-2,-3,4,-1,-2,1,5,2]);

【讨论】：

【解决方案2】：

function maxSubarray(a) {
    var l=a.length;

    if (!l) {
        return;
    }

    var ps, ms;
    ps=ms=a[0];

    for(var i=1; i<l; i++) {
        ps=Math.max(a[i],ps+a[i]);
        ms=Math.max(ms,ps);
    }

    return ms;
}

【讨论】：

虽然此代码可能会解决问题，但 including an explanation 关于如何以及为什么解决问题将真正有助于提高您的帖子质量，并可能导致更多的赞成票。请记住，您正在为将来的读者回答问题，而不仅仅是现在提问的人。请edit您的答案以添加解释并说明适用的限制和假设。 From Review

【解决方案3】：

刚看到这个，它会找到最大子数组的总和

public class MaxSubArray{
static void sumM(int a[], int n){
    int s1 = Integer.MAX_VALUE;
    int k = Integer.MAX_VALUE;
    int sum = 0;
    int s2 = 0;
    for(int i=0;i<n;i++){

        if(a[i]<s1){
            if(a[i]<0){
                k = Math.min(a[i],s1);
            }
        }

        if(a[i]>k){
            sum+=a[i];
        }

        if(a[i]<k){
            if(a[i]<0){
                continue;
                
            }
            s2+=a[i];
        }

    }
        if(sum>s2){
            System.out.println(sum);
        }
        else{
            System.out.println(s2);
        }
    
     
}

    public static void main(String[] args){
        int a[] = {1,2,3,-7,4,5};

        int n = a.length;

        sumM(a,n);
    }

    
}

【讨论】：

【解决方案4】：

var maxSubArray = function(nums) {
  let maxn = Number.MIN_VALUE; // Or Number.MIN_SAFE_INTEGER
  let sum = 0;

  nums.forEach(function(item, index, array) {
    sum += item;

    if (sum > maxn)
      maxn = sum;

    if (sum < 0)
      sum = 0;
  });

  return maxn;
};


console.log(maxSubArray([-2,1,-3,4,-1,2,1,-5,4])) // === 6
console.log(maxSubArray([-2, -1])) // === -1
console.log(maxSubArray([-2,1])) // === 1
console.log(maxSubArray([1])) // === 1
console.log(maxSubArray([1, 2])) // === 3

【讨论】：

太棒了，我很感激。