已知一个整型数组arr，数组长度为size且size大于2，arr有size-1种 可以划分成左右两部分的方案

已知一个整型数组arr，数组长度为size且size大于2，arr有size-1种 可以划分成左右两部分的方案。

比如： arr = {3, 2, 3, 4, 1, 2}

第1种划分左部分为[3]，右部分为[2, 3, 4, 1, 2]

第2种划分左部分为[3, 2]，右部分为[3, 4, 1, 2]

第3种划分左部分为[3, 2, 3]，右部分为[4, 1, 2]

第4种划分左部分为[3, 2, 3, 4]，右部分为[1, 2]

第5种划分左部分为[3, 2, 3, 4, 1]，右部分为[2]
每一种划分下，左部分都有最大值记为max_left，右部分都有最大值记 为max_right。 求|max_left-max_right|(左部分最大值与左部分最大值之差的绝对值)， 最大是多少？ 要求：时间复杂度为O(N)，额外空间复杂度O(1)

 

1.最笨的方法就是从下标0开始依次分左右部分，然后分别遍历找最大值，需要遍历n次，一次遍历n个位置，所以时间复杂度为O(n*n)

2.这道题涉及到一个思想，辅助数组，当我们想拿左部分的最大值时我们可以直接从数组里拿，而不用遍历，当想拿右部分最大值的时候同理

如何做？

准备两个数组，Max_left和Max_right，数组大小与题中数组大小一样，以题中arr数组为例

从arr[0]开始遍历，将arr[0]的值放入Max_left[0]中，然后arr[1]，如何arr[1]大于arr[0]，则Max_left[1]里放的时arr[1]，如果arr[0]>arr[1]则Max_left里放的时arr[0]，即Max_left[i]里放的时[ arr[0]，arr[i] ]中最大的值，同理Max_right是下标从n-1开始往左遍历，Max_right[n-1]里放到是[ i , n-1 ] 里的最大值，所以两个数组取最大值相减得绝对值的时候，Max_right的下标比Max_left的下标大一，比如| Max_left[0]-Max_right[1]，遍历找去绝对值最大

3.最简单的一种方法，找出数组中最大的值max，然后max减去左右边界（下标0和下标n-1)比较小的那个数就是答案 

为什么？

数组最大值肯定位于左右部分中的其中一个，max要减一个另外一部分最大值。假设max位于左部分，则右部分的最大值要比较小，设下标n-1位置的数为L，L处于的右部分的最大值肯定是大于等于L的，所以当右部分只有L时，则右部分的最大值最小；同理，假设max位于右部分，则左部分的最大值要比较小，设下标0位置的数为R，R处于的左部分的最大值肯定是大于等于R的，所以当左部分只有R时，则左部分的最大值最小。还有一种情况就是max位于边界，但这种情况和上面的两种情况分析一样。

代码：

 

public class MaxABSBetweenLeftAndRight {

    public static int maxABS1(int[] arr) {
        int res = Integer.MIN_VALUE;
        int maxLeft = 0;
        int maxRight = 0;
        for (int i = 0; i != arr.length - 1; i++) {
            maxLeft = Integer.MIN_VALUE;
            for (int j = 0; j != i + 1; j++) {
                maxLeft = Math.max(arr[j], maxLeft);
            }
            maxRight = Integer.MIN_VALUE;
            for (int j = i + 1; j != arr.length; j++) {
                maxRight = Math.max(arr[j], maxRight);
            }
            res = Math.max(Math.abs(maxLeft - maxRight), res);
        }
        return res;
    }

    public static int maxABS2(int[] arr) {
        int [] Max_left = new int[arr.length];
        int [] Max_right = new int[arr.length];
        Max_left[0] = arr[0];
        Max_right[arr.length - 1] = arr[arr.length - 1];
        for (int i = 1; i < arr.length; i++) {
            Max_left[i] = Math.max(Max_left[i - 1],arr[i]);
        }
        for (int i = arr.length - 2; i > -1; i--) {
            Max_right[i] = Math.max(Max_right[i + 1], arr[i]);
        }
        int max = 0;
        for (int i = 0; i < arr.length - 1; i++) {
            max = Math.max(max, Math.abs(Max_left[i] - Max_right[i + 1]));
        }
        return max;
    }

    public static int maxABS3(int[] arr) {
        int max = Integer.MIN_VALUE;
        for (int i = 0; i < arr.length; i++) {
            max = Math.max(arr[i], max);
        }
        return max - Math.min(arr[0], arr[arr.length - 1]);
    }

    public static int[] generateRandomArray(int length) {
        int[] arr = new int[length];
        for (int i = 0; i != arr.length; i++) {
            arr[i] = (int) (Math.random() * 1000) - 499;
        }
        return arr;
    }

    public static void main(String[] args) {
        int[] arr = generateRandomArray(200);
        System.out.println(maxABS1(arr));
        System.out.println(maxABS2(arr));
        System.out.println(maxABS3(arr));
    }
}