Our treatment of this problem is taken from Chapter 8 of the book Programming Pearls, second edition, by Jon Bentley. The chapter and the book are wonderful to read, and I highly recommend them. The author provides a brief sketch of the chapter in the form of lecture notes in PDF format, as well as the source code for the algorithms (in C), together with a convenient driver.

I offer my own Python implementation and test harness.

This problem is also introduced in Chapter 4.1 of CLRS, with a presentation of the O(n log n) divide-and-conquer algorithm. (The linear time algorithm is the subject of Exercise 4.1-5.)

The problem is to take as input an array of n values (some of which may be negative), and to find a contiguous subarray which has the maximum sum. For example, consider the array:

We consider five distinct algorithms for solving this problem.

Algorithm 1:   A Cubic Algorithm (i.e., O(n³ ) )

maxsofar = 0;
for (i = 0; i < n; i++)
    for (j = i; j < n; j++) {
        sum = 0;
        for (k = i; k <= j; k++)
            sum += A[k];
            if (sum > maxsofar)
                maxsofar = sum;
    }

Algorithm 2:   A Quadratic Algorithm (i.e., O(n² ) )

maxsofar = 0;
for (i = 0; i < n; i++) {
    sum = 0;
    for (j = i; j < n; j++) {
        sum += A[j];   // sum is that of A[i..j]
        if (sum > maxsofar)
            maxsofar = sum;
    }
}

Algorithm 2b:   Another Quadratic Algorithm (i.e., O(n² ) )

maxsofar = 0;
cumarr[-1] = 0;
for (i = 0; i < n; i++)
    cumarr[i] = cumarr[i-1] + A[i];
for (i = 0; i < n; i++) {
    for (j = i; j < n; j++) {
        sum = cumarr[j] - cumarr[i-1];   // sum is that of A[i..j]
        if (sum > maxsofar)
            maxsofar = sum;
    }
}

Algorithm 3:   An O(n log n) Algorithm

float recmax(int l, int u)
    if (l > u)  /* zero elements */
        return 0;
    if (l == u)  /* one element */
        return max(0, A[l]);
    m = (l+u) / 2;
    /* find max crossing to left */
    lmax = sum = 0;
    for (i = m; i ≥ l; i--) {
        sum += A[i];
        if (sum > lmax)
            lmax = sum;
    }
    /* find max crossing to right */
    rmax = sum = 0;
    for (i = m+1; i ≤ u; i++) {
        sum += A[i];
        if (sum > rmax)
            rmax = sum;
    }
    return max(max(recmax(l, m),
                   recmax(m+1, u)),    
               lmax + rmax);
}

Algorithm 4:   A Linear Algorithm (i.e., O(n) )

maxsofar = 0
maxendinghere = 0;
for (i = 0; i < n; i++) {
    maxhere = max(maxhere + A[i], 0)
    maxsofar = max(maxsofar, maxhere)
}