一个有n个元素的数组,则n个元素既可以是正数也可以是负数,数组中连续的一个或多个元素可以组成一个连续的子数组,一个数组可能有多个这种连续的子数组,求子数组和的最大值。
分析:
方法一:蛮力法
最简单的也是最容易的方法就是找出所有的子数组,然后求出数组的和,在所有子数组的和中取最大值。
实现代码:
package lock;
public class T5
{
public static int maxSubArray(int[] arr)
{
if(arr==null||arr.length<=1)
{
System.out.println("输入参数不合理!");
return -1;
}
int ThisSum=0,MaxSum=0,i,j,k;
for(i=0;i<arr.length;i++)
{
for(j=i;j<arr.length;j++)
{
ThisSum=0;
for(k=i;k<j;k++)
ThisSum+=arr[k];
if(ThisSum>MaxSum)
MaxSum=ThisSum;
}
}
return MaxSum;
}
public static void main(String[] arg) {
// TODO Auto-generated method stub
int arr[]= {1,-2,4,8,-4,7,-1,-5};
System.out.println("连续最大的和为:"+maxSubArray(arr));
}
}
运行结果:
算法性能分析:
这种算法的时间复杂度为O(N^ 3),显然效率太低,通过这种算法进行分析发现,许多子数组都重复计算了。
方法二:重复利用已经计算的子数组和
由于Sum[i,j]=Sum[i,j-1]+arr[j],在计算Sum[i,j]时可以使用前面已经计算出的Sum[i,j-1]而不需要重新计算,采用这种方法可以省去Sum[I,j-1]的时间,因此可以提高程序的效率,节省运算时间。
实现代码如下:
package lock;
public class T6 {
public static int maxSubArray(int[] arr)
{
if(arr==null||arr.length<=1)
{
System.out.println("输入参数不合理!");
return -1;
}
int maxSum=Integer.MIN_VALUE;
for(int i=0;i<arr.length;i++)
{
int sum=0;
for(int j=i;j<arr.length;j++)
{
sum+=arr[i];
if(sum>maxSum)
{
maxSum=sum;
}
}
}
return maxSum;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
int arr[]= {1,-2,4,8,-4,7,-1,-5};
System.out.println("连续最大的和为:"+maxSubArray(arr));
}
}
实验结果:
算法性能分析:
这种方法是用来双重循环,因此,时间复杂度为O(N^ 2)。
方法三:动态规划方法
可以采用动态规划的方法来降低算法的时间复杂度。
首先可以根据数组的最后一个元素arr[n-1]与最大子数组的关系分为以下三种情况讨论:
1)最大数组包含arr[n-1],即最大数组以arr[n-1]结尾。
2)arr[n-1]单独构成最大数组。
3)最大数组不包括arr[n-1],那么arr[1…n-1]的最大子数组可以转化为arr[1…n-2]的最大子数组。
实现代码:
package lock;
public class T7 {
public static int maxSubArray(int[] arr)
{
if(arr==null||arr.length<=1)
{
System.out.println("输入参数不合理!");
return -1;
}
int n=arr.length;
int[]End=new int[n];
int[]All=new int[n];
End[n-1]=arr[n-1];
All[n-1]=arr[n-1];
End[0]=All[0]=arr[0];
for(int i=1;i<n;++i)
{
End[i]=Integer.max(End[i-1]+arr[i], arr[i]);
All[i]=Integer.max(End[i],All[i-1]);
}
return All[n-1];
}
public static void main(String[] args) {
// TODO Auto-generated method stub
int arr[]= {1,-2,4,8,-4,7,-1,-5};
System.out.println("连续最大的和为:"+maxSubArray(arr));
}
}
实验结果:
算法性能分析:
与前面两种方法相比,这种方法的时间复杂度为O(N),显然效率更高,但是由于在计算的过程中额外申请了两个数组,因此该方法的空间复杂度也为O(N)。
方法四:优化的动态规划方法
可以定义两个变量来保存End[i-1]与All[i-1],并且可以重复利用。
实现代码:
package lock;
public class T8 {
public static int maxSubArray(int[] arr)
{
if(arr==null||arr.length<=1)
{
System.out.println("输入参数不合理!");
return -1;
}
int nAll=arr[0]; //最大子数组和
int nEnd=arr[0]; //包含最后一个元素的最大子数组和
for(int i=1;i<arr.length;++i)
{
nEnd=Integer.max(nEnd+arr[i],arr[i]);
nAll=Integer.max(nEnd,nAll);
}
return nAll;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
int arr[]= {1,-2,4,8,-4,7,-1,-5};
System.out.println("连续最大的和为:"+maxSubArray(arr));
}
}
运行结果:
算法性能分析:
这种方法在保证了时间复杂度为O(N)的基础上,把算法的空间复杂度也降到O(1)。
引申:
在知道子数组最大值后,如何才能确定最大子数组的位置
分析:
为了得到最大子数组的位置,首先介绍另外一种最大子数组和的方法。通过公式End[i]=max(End[i-1]+arr{i},arr[i])的分析可以看出,当End[i-1]<0时,End[i]=array[i],其中End[i]表示包含array[i]的数组和,如果某一个值使得End[i-1]<0,那么就从arr[i]重新开始。可以利用这个性质非常容易地确定最大子数组的位置。
实现代码:
package lock;
public class T9 {
private int begin=0; //记录最大子数组的起始位置
private int end=0; //记录最大子数组的结束位置
public int maxSubArray(int[] arr){
int n=arr.length;
int maxSum=Integer.MIN_VALUE; //子数组最大值
int nSum=0; //包含子数组最后一位的最大值
int nStart=0;
for(int i=0;i<n;i++) {
if(nSum<0)
{
nSum=arr[i];
nStart=i;
}else {
nSum+=arr[i];
}
if(nSum>maxSum) {
maxSum=nSum;
begin=nStart;
end=i;
}
}
return maxSum;
}
public int getBegin() {return this.begin;}
public int getEnd() {return this.end;}
public static void main(String[] args) {
// TODO Auto-generated method stub
T9 t=new T9();
int arr[]= {1,-2,4,8,-4,7,-1,-5};
System.out.println("连续最大的和为:"+t.maxSubArray(arr));
System.out.println("最大和对应的数组起始与结束坐标分别为:"+t.getBegin()+","+t.getEnd());
}
}