环形二维子数组求最大子数组

一、设计思路

  之前我们已经写出了环形一维数组的最大子数组，现在我们只需要先随机出二维数组，将二维数组转化为一维数组，再调用这个求一维最大子数组的函数，即可求出结果。

  将二维数组转化为一维数组，再通过一维数组间接求出二维数组的最大子数组的方法与欢龙的方法异曲同工。我的方法是以一行为起点，然后从这一行一直加到最后一行，每加一行即产生可以向一维数组函数传递的一维数组。起始行依次向下递增，一直到最后一行。

二、代码

//环形一维数组求最大子数组
package erwei;

public class oneArray {

    private int i;
    public static int maxS;
    public int maxShou;
    public int maxWei;
    void getMax(int[] a,int n){
        boolean x = false;
        for(i = 0;i < n;i++)
        {
            if(a[i] >= 0)
            {
                x = true;
                break;
            }
        }
        
        int sum=0,s1=0,s2=0,loc=0,loc1=0;
        if(x == true)          //有正数的情况下
        {
            for(i = 0;i < n;i++)        //全部为正数的情况下
            {
                s2 += a[i];
                if(a[i] >= 0)
                    sum += a[i];
                if(sum == s2)
                {
                    s2 = sum;
                    loc1 = n;
                }
                else
                    break;
            }
            if(a[0]>=0)            //默认的开头第一个数即为正数
            {
                sum=a[0];
                for(i=1;i<n;i++)
                {
                    if(a[i]>=0)
                    {
                        sum+=a[i];
                    }
                    else
                    {
                    if(sum>=s1)
                        s1=sum;
                    loc=i;
                    if(a[i]<0)
                        sum=0;
                    break;
                    }
                }
                
                int sum1=0;
                for(i=0;i<n;i++)
                {
                    if(a[i]>=0)
                    {
                        sum1+=a[i];
                    }
                    else 
                    {
                        if(sum1>=s2)
                        {
                            s2=sum1;
                            loc1=i;
                        }
                        if(a[i]<0)
                            sum1=0;
                    }
                }
                int s3=0,loc2=0;
                if(a[n-1]>=0)
                {
                    sum=a[n-1];
                    for(i=n-2;i>=0;i--)
                    {
                        if(a[i]>=0)
                        {
                            sum+=a[i];
                        }
                        else{
                        s3=sum;
                        loc2=i;
                        break;}
                    }
                }
                int s4=s1+s3;
                if(s2>=s4)
                {
                    maxS = s2;
                    maxShou = 0;
                    for(i=0;i<loc1;i++)
                    {
                        if(a[i]>0)
                        {
                            maxWei = i;
                        }
                        else 
                            break;
                    }
                    /*
                    System.out.print("最大子数组和为："+s2);
                    System.out.println();
                    System.out.println("子数组为:");
                    for(i=0;i<loc1;i++)
                    {
                        if(a[i]>0)
                        {
                            System.out.print(a[i]+"	");
                        }
                        else 
                            break;
                    }
                    */
                }
                else 
                {
                    maxS = s4;
                    maxShou = loc2 + 1;
                    maxWei = loc - 1;
                    /*
                    System.out.print("最大子数组和为："+s4);
                    System.out.println();
                    System.out.println("子数组为:");
                    for(i=0;i<loc;i++)
                    {
                         System.out.print(a[i]+"	");
                    }
                    for(i=n-1;i>loc2;i--)
                    {
                        System.out.print(a[i]+"	");
                    }
                    */
                }
            }
            else                  //默认的开头第一个数为负数
            {
                sum=0;
                for(i=0;i<n;i++)
                {
                    if(a[i]>=0)
                    {
                        sum+=a[i];
                        if(i==n-1&&sum>s1)
                            s1=sum;
                            loc=i;
                    }
                    else 
                    {
                        if(sum>=s1)
                        {
                            s1=sum;
                            
                        }
                        if(a[i]<0)
                            sum=0;
                    }
                }
                maxS = s1;
                maxWei = loc;
                for(i=loc;i>=0;i--)
                {
                    if(a[i]>0)
                    {
                        maxShou = i;
                    }
                    else 
                        break;
                }
                /*
                System.out.println("lovc"+loc);
                System.out.print("最大子数组和为："+s1);
                System.out.println();
                for(i=loc;i>=0;i--)
                {
                    if(a[i]>0)
                    {
                        System.out.print(a[i]+"	");
                    }
                    else 
                        break;
                }
                */
            }
        }
        else if(x == false)              //没有正数的情况下
        {
            int t = a[0];
            for(i = 1;i < n;i++)
            {
                if(a[i] > t)
                {
                    t = a[i];
                    maxShou = i;
                    maxWei = i;
                }
            }
            maxS = t;
            /*
            System.out.print("最大子数组和为："+t);
            System.out.println();
            System.out.println("子数组为:");
            System.out.print(t);
            */
        }
    }
    public int getmaxS(){
        return maxS;
    }
    public int getmaxShou(){
        return maxShou;
    }
    public int getmaxWei(){
        return maxWei;
    }
}
//环形二维数组求最大子数组
package erwei;

import java.util.*;

public class twoArray extends oneArray{

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Scanner sc = new Scanner(System.in);
        
        int max,min,numL,numR;
        int i,j,t;
        int shouL,shouR,weiL,weiR,maxTwo;
        
        System.out.println("请输入二维数组的行数和列数：");
        numL = sc.nextInt();
        numR = sc.nextInt();
        
        System.out.println("请输入数组元素取值范围（保证前一个值小于后一个值）：");
        min = sc.nextInt();
        max = sc.nextInt();
        
        int[][] twoArray1 = new int[numL][numR];
        int[] oneArray1 = new int [numR];
        int LTop;
        
        System.out.println("该二维数组为：");                         //生成随机二维数组
        for(i = 0;i < numL;i++)
            for(j = 0;j < numR;j++){
                twoArray1[i][j] = min + (int)(Math.random()*(max - min));
                System.out.print(twoArray1[i][j] + "	");
                if(j == numR - 1){
                    System.out.println();
                }
            }
        
        maxTwo = twoArray1[0][0];
        shouL = 0;
        shouR = 0;
        weiL = 0;
        weiR = 0;
        
        for(i = 0;i < numR;i++){                                    //一维数组赋初值
            oneArray1[i] = 0;
        }
        System.out.println();
        oneArray one = new oneArray();
        for(LTop = 0;LTop < numL;LTop++){                          //二维数组合并为一维数组    
            for(i = LTop;i < numL;i++){
                for(j = 0;j < numR;j++){
                    oneArray1[j] += twoArray1[i][j];
                }
                one.getMax(oneArray1, numR);
                if(one.getmaxS() > maxTwo){
                    maxTwo = one.getmaxS();
                    shouL = LTop;
                    shouR = one.getmaxShou();
                    weiL = i;
                    weiR = one.getmaxWei();
                }
            }
            for(t = 0;t < numR;t++){
                        oneArray1[t] = 0;
            }    
        }
        
        System.out.println("环形二维数组最大子数组和为：");
        System.out.println(maxTwo);
        System.out.println("该最大子数组为：");
        if(shouR > weiR){
            for(i = shouL;i <= weiL;i++){
                for(j = shouR;j < numR;j++){
                    System.out.print(twoArray1[i][j] + "	");
                }
                for(j = 0;j <= weiR;j++){
                    System.out.print(twoArray1[i][j] + "	");
                }
                System.out.println();
            }
        }
        else{
            for(i = shouL;i <= weiL;i++){
                for(j = shouR;j <= weiR;j++){
                    System.out.print(twoArray1[i][j] + "	");
                }
                System.out.println();
            }
        }
        
        sc.close();
    }

}

三、设计过程

  在实现过程中，一开始使用接口，后来使用另建一个新类来调用，类的使用还更熟练一些。

  编写的过程中大概有一个半小时卡在了将二维转化为一维数组的过程。一开始的想法是：

  1）设出首行和末行，首行与末行在同一位置；

  2）先保持首行不变，求出首行到末行相加后的一维数组；

  3）末行依次递增到最后一行；

  4）当末行递增到最后一行后，首行向下一行，末行再回到与首行相同的位置，重复2），3）直到首行也到达最后一行。

  可怎么也求不出正确相加的一维数组，突然想到为什么要让末行变来变去，只要保持首行不变，末行一直加到最后一行，只不过每加一行就可以向一维数组传递，加到最后一行后就让首行向下移动即可，首行一直移动到最后一行。

四、实验结果

非负：

有正有负：

全负：

五、结对成员

  刘双渤、刘洪阳。

  思路：刘双渤、刘洪阳。

  编程：刘双渤、刘洪阳。