算法导论第三章

最大子数组

package com.gds.algorithms;

public class Tuple {
    private int leftIndex;
    private int rightIndex;
    private int sum;

    public Tuple(int leftIndex, int rightIndex, int sum) {
        this.leftIndex = leftIndex;
        this.rightIndex = rightIndex;
        this.sum = sum;
    }

    /**
     * @return the leftIndex
     */
    public int getLeftIndex() {
        return leftIndex;
    }

    /**
     * @param leftIndex the leftIndex to set
     */
    public void setLeftIndex(int leftIndex) {
        this.leftIndex = leftIndex;
    }

    /**
     * @return the rightIndex
     */
    public int getRightIndex() {
        return rightIndex;
    }

    /**
     * @param rightIndex the rightIndex to set
     */
    public void setRightIndex(int rightIndex) {
        this.rightIndex = rightIndex;
    }

    /**
     * @return the sum
     */
    public int getSum() {
        return sum;
    }

    /**
     * @param sum the sum to set
     */
    public void setSum(int sum) {
        this.sum = sum;
    }

}

package com.gds.algorithms;

public class FindSubarray {
    public static Tuple findMaxCrossingSubarray(int[] A, int low, int mid, int high) {
        int leftSum = Integer.MIN_VALUE;
        int sum1 = 0;
        int maxLeft = 0;
        for (int i=mid; i >= low; i--) {
            sum1 = sum1 + A[i];
            if (sum1 > leftSum) {
                leftSum = sum1;
                maxLeft = i;
            }
        }

        int rightSum = Integer.MIN_VALUE;
        int sum2 = 0;
        int maxRight = 0;
        for (int j = mid+1; j <= high; j++) {
            sum2 = sum2 + A[j];
            if (sum2 > rightSum) {
                rightSum = sum2;
                maxRight = j;
            }
        }

        Tuple t1 = new Tuple(maxLeft, maxRight, leftSum + rightSum);
        return t1;

    }

    public static Tuple findMaximumSubarray(int[] A, int low, int high) {
        Tuple t = null;
        if (high == low) {
            t = new Tuple(low, high, A[low]);
            return t;
        } else {
            int mid = Math.floorDiv(low+high, 2);
            int leftLow = findMaximumSubarray(A, low, mid).getLeftIndex();
            int leftHigh = findMaximumSubarray(A, low, mid).getRightIndex();
            int leftSum = findMaximumSubarray(A, low, mid).getSum();

            int rightLow = findMaximumSubarray(A, mid+1, high).getLeftIndex();
            int rightHigh = findMaximumSubarray(A, mid+1, high).getRightIndex();
            int rightSum = findMaximumSubarray(A, mid+1, high).getSum();

            int crossLow = findMaxCrossingSubarray(A, low, mid, high).getLeftIndex();
            int crossHigh =findMaxCrossingSubarray(A, low, mid, high).getRightIndex();
            int crossSum = findMaxCrossingSubarray(A, low, mid, high).getSum();

            if (leftSum >= rightSum && leftSum >= crossSum) {
                t = new Tuple(leftLow, leftHigh, leftSum);
                return t;
            } else if (rightSum >= leftSum && rightSum >= crossSum) {
                t = new Tuple(rightLow, rightHigh, rightSum);
                return t;
            } else {
                t = new Tuple(crossLow, crossHigh, crossSum);
                return t;
            }

        }

    }

    public static void main(String[] args) {
        int[] A = {13,-3,-25,20,-3,-16,-23,18,20,-7,12,-5,-22,15,-4,7};
        Tuple t = findMaximumSubarray(A, 0, A.length-1);
        int low = t.getLeftIndex();
        int high = t.getRightIndex();
        int sum = t.getSum();
        System.out.println("low: "+ low + "\n" + "high: " + high + "\n" + "sum: " + sum);
    }
}