C#中求数组的子数组之和的最大值

《编程之美》183页，问题2.14——求子数组的字数组之和的最大值。（整数数组）

我开始以为可以从数组中随意抽调元素组成子数组，于是就有了一种想法，把最大的元素抽出来，判断是大于0还是小于等于0，如果大于0就对除了这个最大值外剩下的数组部分进行递归：

using System;
using System.Collections.Generic;
using System.Linq;

namespace MaxSumSubArray
{
    class Program
    {
        static void Main(string[] args)
        {
            List<int> array = new List<int>() { -1, -2, 1, 2, -1, 1, -3, 6 - 3, -4, 1 };
            List<int> subArray = new List<int>();
            if (array.Max() > 0)
            {
                MaxSumSubArray(array, subArray);
                PrintArray(subArray);
            }
            else
            {
                Console.Write("The max sub-array is {" + array.Max() + "}");
            }
            Console.ReadLine();
        }

        private static void PrintArray(List<int> subArray)
        {
            Console.WriteLine("The max-sum sub-array is:");
            foreach (int num in subArray)
            {
                Console.Write(num);
                Console.Write(" ");
            }
        }

        private static void MaxSumSubArray(List<int> array, List<int> subArray)
        {
            if (array.Max() > 0)
            {
                subArray.Add(array.Max());
                array.Remove(array.Max());
                MaxSumSubArray(array,subArray);
            }
        }
    }
}

这样做其实就是我想麻烦了，因为最后的结果证明，这样做和遍历数组把大于0的元素都抽出来是一样的，根本用不着递归：

如果数组中没有正整数，那就变成求数组中最大值的问题了。T.T

后来看答案发现，题中说的子数组还必须得是连续的，不能随便抽调。于是开始重新想问题……

我发现，连续子数组的和是不是最大的，要把所有的子数组都找出来以后才能确定。

那没什么好办法了，只能遍历了，首先从第一个元素开始，第一个子数组就是第一个元素本身，第二个子数组就是第一个元素和第二个元素组成的，第三个……

然后从第二个元素开始……

等把这些子数组都列出来以后，分别加和，比较一下哪个最大哪个就是目标子数组了。

代码如下：

using System;
using System.Collections.Generic;
using System.Linq;

namespace MaxSumSubArray
{
    class Program
    {
        static void Main(string[] args)
        {
            List<int> array = new List<int>() { -2, 5, 3, -6, 4, -8, 6 };
            List<List<int>> subArrays = new List<List<int>>();
            int subSum = 0;
            int origin = 0;
            for (int k = 1; k <= array.Count(); k++)
            {
                for (int i = k; i <= array.Count(); i++)
                {
                    subArrays.Add(new List<int>());
                    for (int j = k; j <= i; j++)
                    {
                        subArrays[origin].Add(array[j - 1]);
                        subSum += array[j - 1];
                    }
                    subArrays[origin].Add(subSum);
                    origin++;
                    subSum = 0;
                }
            }
            int max = subArrays[0][subArrays[0].Count() - 1];
            int destination = 0;
            for (int i = 0; i < subArrays.Count(); i++)
            {
                int sumIndex = subArrays[i].Count() - 1;
                if (subArrays[i][sumIndex] > max)
                {
                    max = subArrays[i][subArrays[i].Count() - 1];
                    destination = i;
                }
            }
            PrintArray(subArrays[destination]);
            Console.ReadLine();
        }

        private static void PrintArray(List<int> array)
        {
            Console.WriteLine("The max-sum sub-array is:");
            for (int i = 0; i < array.Count() - 1; i++)
            {
                Console.Write(array[i]);
                Console.Write(" ");
            }
            Console.WriteLine();
            Console.WriteLine("The sum of the array is:" + array[array.Count() - 1]);
        }
    }
}

这里我用了泛型数组的嵌套，因为泛型数组是动态的，所以嵌套的泛型数组就相当于一个动态的二维数组：

List<List<int>> subArrays = new List<List<int>>();

subArrays数组中每一个元素都是一个整型数组List<int>。

接下来是三层for循环：

最内层的for循环就是从数组的某一个元素一直加到某一个元素；

中层for循环是从数组某一个元素开始，一直到最后一个元素；

最外层的for循环是用来指定子数组的首元素。

通过三层for循环就可以求出所有的子数组以及他们的和，我把每一个子数组都做为一个元素存在List<int>型数组中，并且int型数组中的最后一位元素用来存子数组的和。

接下来我们遍历所有子数组的末尾元素，比较出所有子数组中和最大的子数组并将其打印。

至此，我们就求出了数组中和最大的子数组：

以上就是经过我的思考所得出的解法。对比书中的解法发现我的解法基本上是书中写的没有优化过的解法一，但细节实现不一样，我的方法不光可以找出最大子数组和，还可以打印对应数组。书中说可以省略一层for循环来避免重复计算对算法进行优化，但是我没想通，改成书中说的那样发现测试结果不对。如果哪位高手有好意见，请给出优化代码。QQQ~！