循环一维数组求最大子数组

题目：

  随机出一个一维数组，设该数组为循环数组，求其最大小子数组。

一、设计思路

  求最大子数组，就求出最大的连续正子数组。

  将数组分为全负和有非负值两种情况。全负求出最大值即可。

  在有非负值的情况下，先判断该随机数组的首尾是否相连，即首尾是否都大于等于零。如果首尾相连，则将该一维数组分为首、中、尾三部分，先求出首尾和S1，再求中间最大连续正子数组和S，令S1和S与maxS相比较，求出最大子数组；如果首尾不相连，则直接借鉴前一种情况中部的算法，求最大正子数组S。

二、源代码

//刘双渤，刘洪阳，循环一维数组求最小子数组
package zishuzu;
import java.util.*;

public class zuidazishuju {

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

        Scanner sc = new Scanner(System.in);
        
        int n,max,min;
        int i;
        System.out.println("请输入一维数组的长度：");
        n = sc.nextInt();
        System.out.println("请输入该数组元素的取值范围（请保证前一个值小于后一个值）：");
        min = sc.nextInt();
        max = sc.nextInt();
        
        int[] a = new int[n];
        
        for(i = 0;i < n;i++)
        {
            a[i] = min + (int)(Math.random()*(max-min));
        }
        
        System.out.println("该一维循环随机数组为：");
        for(i = 0;i < n;i++)
        {
            System.out.print(a[i] + "	");
        }
        System.out.println();
        
        int maxS,shouS1 = 0,weiS1 = 0,shouS = 0,weiS = 0,S,S1;
        int js,midSta = 0,midSta1 = 0,loci;
        int[] loc = new int[n];
        int judge = 0;
        
        for(i = 0;i < n;i++)                       //判断数组元素是否含有非负数
        {
            if(a[i] >= 0)
            {
                judge = 1;
                midSta1 = i;
                break;
            }
        }
        maxS = a[0];
        S = 0;
        S1 = 0;
        js = 0;
        loci = 0;
        if(judge == 0)                             //所有元素小于零
        {
            for(i = 0;i < n;i++)
            {
                if(a[i] > maxS)
                {
                    maxS = a[i];
                    loci = 0;
                    loc[loci] = i+1;
                }
                else if(a[i] == maxS)
                {
                    loci += 1;
                    loc[loci] = i +1;
                }
            }
            System.out.println("最大子数组和为：" + maxS);
            System.out.println("数组第一个元素位置为"1"");
            System.out.print("最大子数组所在位置为：");
            for(i = 0;i <= loci;i++)
            {
                System.out.print(loc[i] + " ");
            }
        }
        else                                      //正负同时存在
        {
            if(a[0] >= 0 && a[n - 1] >= 0)            //第一个元素和最后一个元素非负
            {
                for(i = 0;i < n;i++)             //从0开始求第一个连续非负子数组
                {
                    if(a[i] >= 0)
                    {
                        S1 += a[i];
                        weiS1 = i + 1;
                        if(i == n -1)
                        {
                            shouS1 = 1;
                        }
                    }
                    else
                    {
                        break;
                    }
                }
                for(i = n - 1;i > weiS1;i--) //从n-1开始求连续非负子数组
                {
                    if(a[i] >= 0)
                    {
                        S1 += a[i];
                        shouS1 = i +1;
                    }
                    else
                    {
                        break;
                    }
                }
                if(S1 >= maxS)                  //首尾相连子数组与maxS比较
                {
                    maxS = S1;
                    shouS = shouS1;
                    weiS = weiS1;
                }
                for(i = weiS1;i < shouS1 - 1;i++)   //求中间第一个非负数
                {
                    if(a[i] >= 0)
                    {
                        midSta = i;
                        break;
                    }
                    else if(i == shouS1 - 2)
                    {
                        midSta = i + 1;
                    }
                }
                for(i = midSta;i < shouS1 - 1;i++)     //求中间最大连续非负子数组
                {
                    if(a[i] >= 0)
                    {
                        S += a[i];
                        js++;
                    }
                    else
                    {
                        if(S >= maxS)
                        {
                            maxS = S;
                            weiS = i -1;
                            shouS = i -js;
                            js = 0;
                            S = 0;
                        }
                        else
                        {
                            S = 0;
                            js = 0;
                        }
                    }
                }
            }
            else                                     //首尾不是连续非负子数组的情况
            {
                for(i = midSta1;i < n;i++)     //求最大连续非负子数组
                {
                    if(a[i] >= 0)
                    {
                        S += a[i];
                        js++;
                    }
                    else
                    {
                        if(S >= maxS)
                        {
                            maxS = S;
                            weiS = i ;
                            shouS = i -js + 1;
                            js = 0;
                            S = 0;
                        }
                        else
                        {
                            S = 0;
                            js = 0;
                        }
                    }
                }
            }
            System.out.println("最大子数组和为：" + maxS);
            System.out.println("数组第一个元素位置为"1"");
            System.out.println("最大子数组首位置为：" + shouS);
            System.out.println("最大子数组尾位置为：" + weiS);
        }
        sc.close();
    }

}

三、设计过程

  先给出随机一维子数组，然后分情况完成。

  全负情况比较简单，但考虑到有相同最大值存在的情况，于是建立一个一维数组loc[n]来保存相同最大值的位置。验证时，发现多最大值的情况下总是为在输出的位置的最前边多一个，修改初始值解决。

  有非负值情况下，在计算首尾和S1时，如果数组全正，则有可能S1为实际值的两倍，因此根据weiS1来判断首尾位置，避免重复相加。在设计中间部分是，如何跳过负值和保存判断最大子数组和是关键，一开始的想法是在出现第一个非负值的情况下保存判断最大子数组和，并将S，js初始化为0，逻辑上不知没有找出错误，最后使用的方法是在每一个负值出现时就判断保存和初始化，成功。

四、实验结果：

有非负值存在且首尾相连：

有非负值且首尾不想连：

全正：

全负：

五、结组成员

  刘双渤，刘洪阳。

  共同完成设计思路。