线性算法的让人惊叹的效率

这是书中第八章讲到的一道很普通的题目。大致如下：

有个串整数数列，有正有负，要求寻找出该数列中和最大的一段

比如说：1，2，-3，-2，3，6，-1，-3，5，-2，那么应该是3，6，-1，-3，5这段，和为10

什么也不说了，上代码吧

 

具体的算法：

以下初始化的方法、考虑第一个数字和doubleAdd是我自己加上去的，其他书中好像都有

/// <summary> /// 普通算法 /// </summary> /// <param name="nList"></param> static void getMax(List<int> nList) { int max = 0; int start = 0; int end = 0; for (int i = 0; i < nList.Count; i++) { int sum = 0; for (int j = i; j < nList.Count; j++) { sum += nList[j]; if (sum > max) { max = sum; start = i; end = j; } } } Console.WriteLine("the list start from " + start + " and end up with " + end + '/n' + "the maximum number :" + max); } /// <summary> /// 普通算法B /// </summary> /// <param name="nList"></param> static void getMaxB(List<int> nList) { int maxSum = 0; int tempSum; List<int> sumList = new List<int>(); sumList.Add(nList[0]); for (int i = 1; i < nList.Count; i++) { sumList.Add(sumList[i - 1] + nList[i]); } for (int i = 0; i < sumList.Count; i++) { for (int j = i + 1; j < sumList.Count; j++) { tempSum = sumList[j] - sumList[i]; maxSum = Math.Max(tempSum, maxSum); } } } /// <summary> /// 考虑第一个数字，任何一串最大值，肯定不会从一个负数开始的 /// </summary> /// <param name="nList"></param>zm static void getMax2(List<int> nList) { int max = 0; int start = 0; int end = 0; for (int i = 0; i < nList.Count; i++) { if (nList[i] < 0) continue;//多加了这么一步判断 int sum = 0; for (int j = i; j < nList.Count; j++) { sum += nList[j]; if (sum > max) { max = sum; start = i; end = j; } } } Console.WriteLine("the list start from " + start + " and end up with " + end + '/n' + "the maximum number :" + max); } /// <summary> /// 考虑第一个数字，任何一串最大值，肯定不会从一个负数开始的 /// </summary> /// <param name="nList"></param> static void getMax2_half(List<int> nList) { /**通过初始化后，数列是正负数间隔排列的，即如果前一个数字为正数，则下一个必定为负数 * 如果判断每次加数字是以正数开始 * 那么，我每次累加和可以一次加两个数字，（如果该列为最大值，那么肯定也是以负数结尾） * 所以也只有进行初始化后才能调用此程序 */ int max = 0; int start = 0; int end = 0; for (int i = 0; i < nList.Count; i++) { if (nList[i] < 0) continue; int sum = nList[i]; for (int j = i+1; j+1 < nList.Count; j+=2)//每次累加2 { sum += nList[j]+ nList[j+1]; if (sum > max) { max = sum; start = i; end = j; } } } Console.WriteLine("the list start from " + start + " and end up with " + end + '/n' + "the maximum number :" + max); } /// <summary> /// 先初始化然后再搜寻 /// </summary> /// <param name="nList"></param> static void getMax3(List<int> nList) { List<int> nList2 = inital(nList); getMax(nList2); } /// <summary> /// 初始化处理+考虑第一个数字 /// </summary> /// <param name="nList"></param> static void getMax4(List<int> nList) { List<int> nList2 = inital(nList); getMax2(nList2); } /// <summary> /// 初始化处理+考虑第一个数字+每次加两个数字 /// </summary> /// <param name="nList"></param> static void getMax4_Half(List<int> nList) { List<int> nList2 = inital(nList); getMax2_half(nList2); } /// <summary> /// 书上的分治法,个人认为该算法的主要思想,最大值只有可能存在于三种地方:包含中间值的一段、中间值左边那段、中间值右边那段 /// </summary> /// <param name="l"></param> /// <param name="u"></param> /// <param name="nList"></param> /// <returns></returns> static int getMax5(int l, int u, List<int> nList) { if (l > u) return 0; if (l == u) return nList[l]; int m = (l + u) / 2; int maxL = 0, sumL = 0; for (int i = m; i >= 0; i--) { sumL += nList[i]; maxL = Math.Max(maxL, sumL); } int sumR = 0, maxR = 0; for (int i = m + 1; i < u; i++) { sumR += nList[i]; maxR = Math.Max(maxR, sumR); } return Math.Max(Math.Max(maxL + maxR, getMax5(l, m, nList)), getMax5(m + 1, u, nList)); } /// <summary> /// 初始化 + 分治法 /// </summary> /// <param name="nList"></param> /// <returns></returns> static int getMax6(List<int> nList) { //使用了getMax3的方法进行初始化处理 List<int> nList2 = inital(nList); return getMax5(0, nList2.Count - 1, nList2); } /// <summary> /// 伟大的线性算法 /// </summary> /// <param name="nList"></param> /// <returns></returns> static int getMax7(List<int> nList) { /**一开始看书的时候没看懂，看懂了以后真的觉得佩服的一塌糊涂，简介明了，高效 */ int maxSofar = 0, maxEndinghere = 0; for (int i = 0; i < nList.Count; i++) { maxEndinghere = Math.Max(0, maxEndinghere + nList[i]); maxSofar = Math.Max(maxSofar, maxEndinghere); } return maxSofar; } /// <summary> /// 先初始化再调用线性算法 /// </summary> /// <param name="nList"></param> /// <returns></returns> static int getMax8(List<int> nList) { List<int> nList2 = inital(nList); return getMax7(nList2); } /// <summary> /// 初始化 /// </summary> /// <param name="nList"></param> /// <returns></returns> static List<int> inital(List<int> nList) { /**大概是这么个想法，假设有这么一个数列 * 1，2，-3，-4，-2，3，-1，-3不考虑别的，该数列可以把临近相同正负的数加起来得到如下数列 * 3，-9，3，-4 * 处理第二个数列和第一个数列的结果是一样的 * 由该初始化函数我还想到了另外一种算法， * 只要是最大值，第一个数必定是正数，（最大数列）第一个数字的前一个数必定是负数或者空， * 最后一个数必定是正数，最后一个数的下一个数也必定是负数或者空 */ List<int> nList2 = new List<int>(); int subSum = 0; int temp = 1; for (int i = 0; i < nList.Count; i++) { if (temp * nList[i] > 0) { subSum += nList[i]; } else if (temp * nList[i] < 0 && subSum != 0) { nList2.Add(subSum); temp *= -1; subSum = nList[i]; } if (i == nList.Count - 1) { nList2.Add(subSum); } } return nList2; } static List<int> getRandomList(int n, int seed) { Random r = new Random(seed); List<int> nList = new List<int>(); int temp; for (int i = 0; i < n; i++) { temp = r.Next(-50, 50); nList.Add(temp); } return nList; }

 

主函数：

static void Main(string[] args) { Calculagraph c = new Calculagraph(); int seed = DateTime.Now.Millisecond; List<int> nList = getRandomList(10000, seed); List<int> nList2 = getRandomList(10000, seed); c.addWatch("the NormalWay"); getMax(nList); c.setEndWatch("the NormalWay"); c.addWatch("another NormalWay"); getMaxB(nList); c.setEndWatch("another NormalWay"); c.addWatch("first Num"); getMax2(nList); c.setEndWatch("first Num"); c.addWatch("inital"); getMax3(nList); c.setEndWatch("inital"); c.addWatch("inital + firstNum"); getMax4(nList); c.setEndWatch("inital + firstNum"); c.addWatch("inital + firstNum + doubleAdd"); getMax4_Half(nList); c.setEndWatch("inital + firstNum + doubleAdd"); c.addWatch("the way from the PP"); Console.WriteLine("the answer from the PP:" + getMax5(0,nList.Count-1,nList)); c.setEndWatch("the way from the PP"); c.addWatch("the mixture"); getMax6(nList); c.setEndWatch("the mixture"); c.addWatch("the Linear way"); Console.Write("by the Linear way,the answer:" + getMax7(nList2)); c.setEndWatch("the Linear way"); c.addWatch("inital Linear way"); Console.Write("by the Linear way,the answer:" + getMax8(nList2)); c.setEndWatch("inital Linear way"); Console.WriteLine(); Console.WriteLine(c.getTime()); Console.ReadLine(); }

 

调用的方法和类：

/// <summary> /// 初始化 /// </summary> /// <param name="nList"></param> /// <returns></returns> static List<int> inital(List<int> nList) { /**大概是这么个想法，假设有这么一个数列 * 1，2，-3，-4，-2，3，-1，-3不考虑别的，该数列可以把临近相同正负的数加起来得到如下数列 * 3，-9，3，-4 * 处理第二个数列和第一个数列的结果是一样的 * 由该初始化函数我还想到了另外一种算法， * 只要是最大值，第一个数必定是正数，（最大数列）第一个数字的前一个数必定是负数或者空， * 最后一个数必定是正数，最后一个数的下一个数也必定是负数或者空 */ List<int> nList2 = new List<int>(); int subSum = 0; int temp = 1; for (int i = 0; i < nList.Count; i++) { if (temp * nList[i] > 0) { subSum += nList[i]; } else if (temp * nList[i] < 0 && subSum != 0) { nList2.Add(subSum); temp *= -1; subSum = nList[i]; } if (i == nList.Count - 1) { nList2.Add(subSum); } } return nList2; } static List<int> getRandomList(int n, int seed) { Random r = new Random(seed); List<int> nList = new List<int>(); int temp; for (int i = 0; i < n; i++) { temp = r.Next(-50, 50); nList.Add(temp); } return nList; }

 

以下计时的方法也是自己加的

public class Calculagraph { Hashtable htStopWatch = new Hashtable(); public void addWatch(string watchName) { TagOfTime time = new TagOfTime(); htStopWatch.Add(watchName, time); } public void setEndWatch(string watchName) { ((TagOfTime)htStopWatch[watchName]).t2 = DateTime.Now; } public string getTime(string watchName) { TimeSpan ts1 = new TimeSpan(((TagOfTime)htStopWatch[watchName]).t1.Ticks); TimeSpan ts2 = new TimeSpan(((TagOfTime)htStopWatch[watchName]).t2.Ticks); TimeSpan tsDiff = ts1.Subtract(ts2).Duration(); string dateDiff = tsDiff.Days.ToString() + "天" + tsDiff.Hours.ToString() + "小时" + tsDiff.Minutes.ToString() + "分钟" + tsDiff.Seconds.ToString() + "秒" + tsDiff.Milliseconds.ToString() + "毫秒"; return dateDiff; } public string getTime() { string dateDiff = null; foreach (DictionaryEntry de0 in htStopWatch) { dateDiff += de0.Key.ToString() + ":"; dateDiff += getTime(de0.Key.ToString()); dateDiff += '/n'; } return dateDiff; } } /// <summary> /// 时间计时单位类（开始时间，结束时间，间隔的时间） /// </summary> public class TagOfTime { public DateTime t1; public DateTime t2; string TimeTag; public TagOfTime() { t1 = DateTime.Now; } }

 

可以看到，线性算法的查找速度摇摇领先

为了看的更加清楚，我把nList2*100

发现初始化之后调用线性算法反而慢了，看来已经没有初始化的必要了，不过也可以这么说，初始化方法可以再优化