第2章 算法分析

典型的增长率 
c   logN   log2N   N   NlogN   N2   N3   2N 


递归过程调用的一般形式是传递输入的数组以及左边界和右边界，它们界定了数组要被处理的部分。单行驱动程序通过传递数组以及边界0和N – 1而将该过程启动。 


对数最常出现的规律可概括为下列一般法则：如果一个算法用常数事件(O(1))将问题的大小削减为其一部分（通常是1/2），那么该算法就是O(logN)。另一方面，如果使用常熟事件只是把问题减少一个常数的数量（如将问题减少1），那么这种算法就是O(N)的。 

    
    /**
     * //子序列通杀<br>
     * 假设最优子序列是从i开始的,那么从i开始进行运算,求出的最优值一定是最优子序列的值
     * @param a
     * @return
     */
    private static void max(int[] a){
        int maxSum = 0;
        boolean maxfirst = true;
        int thisSum = 0;
        boolean thisfirst = true;
        for(int i = 0;i<a.length;i++){
            thisSum = 0;
            for(int j=i;j<a.length;j++){
                if(thisfirst){
                    thisSum = a[i];
                    thisfirst = false;
                }else {
//                 thisSum += a[j];//和
                    thisSum *= a[j];//乘积
                }
                if(thisSum > maxSum){//求最大子序列 
//                if(thisSum < maxSum){//求最小子序列 
//                 if(thisSum>0&&thisSum < maxSum){//求最小正子序列
//                if(maxfirst&&thisSum<0){//求最大负子序列
                    maxSum = thisSum;
                    maxfirst = false;
                }else if(thisSum>0&&thisSum > maxSum){//求最大子序列乘
//                }else if(thisSum<0&&thisSum > maxSum){//求最大负子序列
                    maxSum = thisSum;
                }
            }
        }
       System.out.println("最优值为:" + maxSum);
    }
    //分治
    private 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;
            }
        }
        int k = maxRightBorderSum > maxLeftBorderSum ? maxRightBorderSum : maxLeftBorderSum;
        int h =  (maxRightBorderSum +maxLeftBorderSum) > k?(maxRightBorderSum +maxLeftBorderSum):k;
        return h;
    }
    
    
    
    /**
     * // 最大/子序列和<br>
     * 最大子序列: 任何负的子序列不可能是最大子序列的前缀<br>
     * 最小子序列: 任何正的子序列不可能是最小子序列的前缀
     * @param a
     * @return
     */
    private static int maxSubSum(int[] a){
        int maxSub = a[0];
       int  maxSum = 0;
        for(int i = 0;i<a.length;i++){
            maxSum += a[i];
//            if(maxSub<maxSum){  // 最大子序列和 else if(maxSum<0
            if(maxSub>maxSum){ //最小子序列和 else if(maxSum>0
                maxSub = maxSum;
            }else if(maxSum>0){
                maxSum = 0;
            }
        }
        return maxSub;
    } 

  //折半查找
    private static <AnyType extends Comparable<? super AnyType>> int  binary(AnyType[] a,AnyType x){
        int low = 0,hight = a.length;
        while(low<=hight){
            int mid = (low+hight)/2;
            if(a[mid].compareTo(x)<0){
                low = mid +1;
            }else if(a[mid].compareTo(x)>0){
                hight = mid -1;
            }else{
                return mid;
            }
        }
        return -1;
    }
   

 
    //欧几里德算法
    private static long gcd(long m,long n){
        while(n!= 0){
            long rem = m%n;
            m= n;
            n = rem;//余数里包含最大公因数
        }
        return m;
    }