算法分析之最大子序列

说到算法，我们的脑海中闪现出的是各种数学公式，各种复杂的逻辑，让人叫苦不迭。其实算法也没那么难，下面给大家介绍很常见的一个典型例子：寻找最大子序列。

将通过四种算法给大家讲解和分析。

方法一：

public static  int maxSubSum1(int [] array){
    int maxSum = 0;

    for(int i=0;i<array.length;i++){
        for (int j=i;j<array.length;j++){
            int thisSum = 0;
            for(int k=i;k<=j;k++){
                thisSum += array[k];
            }
            if(thisSum > maxSum)
                maxSum = thisSum;
        }
    }
    return maxSum;
}

方法一使用的是三重for循环来获取结果，此方法可以正确的获取我们需要的结果。下面我们分析一下时间的复杂度；

第一重for循环的大小为N   第二重for循环的大小为N-i,(取最坏情况为N)       第三重for循环大小为 j - i + 1,我们也假设其大小为N；

故该方法的时间复杂度为O(N*N*N);对于小数据量来说，这个可以满足要求，不过对于大数据可能就会表现的力不从心啦！

方法二：

public static int maxSum2(int[] array){
    int maxSum = 0;
    for(int i=0;i<array.length;i++){
        int thisSum = 0;
        for(int j=i;j<array.length;j++){
            thisSum += array[j];
            if(thisSum > maxSum){
                maxSum = thisSum;
            }
        }
    }
    return maxSum;
}

方法二使用的是两重for循环，同样也满足要求，这个方法等时间复杂度为：N*N，比第一个方法速度快了不少。

方法三：

public static int maxSumRec(int a[],int left,int right){
    if(left == right){
        if(a[left] > 0){
            return a[left];
        }else{
            return 0;
        }
    }
    int center = (left + right) / 2;
    int maxLeftSum = maxSumRec(a,left,center);
    int maxRightSum = maxSumRec(a,center+1,right);
    int maxLeftBorderSum = 0,leftBorderSum = 0;
    for(int i=center;i>=left;i--){
        leftBorderSum += a[i];
        if(leftBorderSum > maxLeftBorderSum){
            maxLeftBorderSum = leftBorderSum;
        }
    }
    int maxRightBorderSum = 0,rightBorderSum = 0;
    for(int i=center+1;i<=right;i++){
        rightBorderSum += a[i];
        if(rightBorderSum > maxRightBorderSum){
            maxRightBorderSum = rightBorderSum;
        }
    }
    return max3(maxLeftSum,maxRightSum,maxLeftBorderSum+maxRightBorderSum);
}
public static int max3(int a,int b,int c){
    int max =0;
    int temp = a>b?a:b;
    max = temp>c?temp:c;
    return max;
}

第三种方法采用的分治算法，也就是所谓的分而治之。分治算法的核心就是使用了递归。

第三种方法等时间复杂度为：N * logN,可见虽然说代码量比前两个多了不少，但是运行效率是比前两个要高效的。

方法四：

public static int maxSubSum3(int[] array){
    int thisSum=0,maxSum=0;
    for(int j=0;j<array.length;j++){
        thisSum += array[j];
        if(thisSum > maxSum){
            maxSum = thisSum;
        }else if(thisSum < 0){
            thisSum = 0;
        }
    }
    return maxSum

方法四的方法的优点在于，数据一次扫描，一旦a[j]被读入并处理，他就不需要再被记忆啦。

方法四的时间复杂度为：N,是一个极其高效的方法。

最后顺带给出几个常见的算法：

1，计算最大公约数的欧几里算法

/**
 * 最大公约数的欧几里算法
 * @param m
 * @param n
 * @return
 */
public static long get(long m ,long n){
    while (n != 0){
        long rem = m % n;
        m = n;
        n = rem;
    }
    return m;
}

2，高效的幂运算

/**
 * 高效的使用递归的幂运算
 * @param x
 * @param n
 * @return
 */
public static long pow(long x,int n){
    if (n == 0) return 1;
    if (n == 1) return x;
    if(n % 2==0){
        return pow(x * x,n/2);
    }else{
        return  pow(x*x,n/2) * x;
    }
}

敬请关注下一章内容：数据分析之表，栈和队列