最大的LeftMax与rightMax之差绝对值

public class Solution {
	/**
	 *	求左部分中的最大值减去右部分最大值的绝对值
	 *	arr：输入数组
	 *	返回：左部分中的最大值减去右部分最大值的绝对值
	 */
    public int getMaxABSLeftAndRight(int[] arr) {
        int max = arr[0];
        //找到整个数组的最大值
        for(int t : arr){
            if(t > max)
                max = t;
        }
        /*
        数组中所有数字都小于等于max，也就是k左边数字都小于max
        设最右数字为r;
        假设[k+1,arr.length-1]中存在比r大 比max小的数字，很明显结果不合题意，k要++
        假设[k+1,arr.length-1]中不存在比r大的数字，那么r就是最大的
         */

        return Math.max(Math.abs(max-(arr[arr.length-1])),Math.abs(max-(arr[0])));
    }
}

public class test {
 public static void main(String[] args) {
 
 int[] arr = {1,3,7,2,4,5,3,9,1,3};
 int max = arr[0];
 int x = 0;
 for (int i = 0; i < arr.length; i ++){
 if (max < arr[i]){
 max = arr[i];
 x = i;
 }
 }
 int max_c = max - arr[0];
 for ( int i = 0; i < x; i ++ ){
 if (max_c > max - arr[i])
 max_c = max - arr[i];
 }
 int max_d = max - arr[arr.length-1];
 for (int i = arr.length - 1; i > x; i --){
 if(max_d >max - arr[i])
 max_d = max - arr[i];
 }
 System.out.println(max_d>max_c?max_d:max_c);
 }
}

static int getMaxABSLeftAndRight(int[] arr) {
     int[] arrTemp=new int[arr.length-1];
     for(int k=0;k<arr.length-1;k++){
     arrTemp[k]=Math.abs(getMax(arr,0,k)- getMax(arr,k+1,arr.length-1));
     }
     return getMax(arrTemp,0,arrTemp.length-1);
 }
 static int getMax(int[] arr,int startPosition,int endPosition){
     int max=0;
     for(int i=startPosition;i<=endPosition;i++){
         if(arr[i]>max){
         max=arr[i];
         }
     }
     return max;
 }

输入：数组/数组长度/k

1. 判断k的有效性

2. 第一段arr1….(k-1)最大值，

3. 第二段最大值

4. 绝对值

public class Solution {
	/**
	 *	求左部分中的最大值减去右部分最大值的绝对值
	 *	arr：输入数组
	 *	返回：左部分中的最大值减去右部分最大值的绝对值
	 */
	public int getMaxABSLeftAndRight(int[] arr) {
		int[] lArr = new int[arr.length];
        int[] rArr = new int[arr.length];
        lArr[0]=arr[0];
        rArr[arr.length-1] = rArr[arr.length-1];
        for(int i=1;i<arr.length;i++) {
            lArr[i] = Math.max(lArr[i-1],arr[i]);
        }
        for(int i=arr.length-2;i>=0;i--) {
            rArr[i] = Math.max(rArr[i+1],arr[i]);
        }
        int max = 0;
        for(int i=0;i<arr.length-1;i++) {
            max = Math.max(max,Math.abs(lArr[i]-rArr[i+1]));
        }
        return max;
	}
}

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

class Solution {
public:
	/**
	 *	求左部分中的最大值减去右部分最大值的绝对值
	 *	vec: 输入数组
     *  len vec的长度
	 *	返回：左部分中的最大值减去右部分最大值的绝对值
	 */
	int getMaxABSLeftAndRight(vector<int> vec, int len) {
        vector<int>::iterator p,pos1,pos2;
        p=vec.begin();
        int k;
        int m=0;
        for(k=0;k<len-1;k++){
            pos1=max_element(p,p+k+1);
            pos2=max_element(p+k+1,p+len);
            m=max(m,(*pos1>*pos2?(*pos1-*pos2):(*pos2-*pos1)));
            
        }
        return m;

    }
};

public class Solution {
 
     public static int getMaxABSLeftAndRight(int[] arr) {
          int res = Integer.MIN_VALUE;
          for (int i = 0; i != arr.length - 1; i++) {
              int maxLeft = Integer.MIN_VALUE;
              for (int j = 0; j != i + 1; j++) {
                  maxLeft = Math.max(arr[j], maxLeft);
              }
             int 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 getMaxABSLeftAndRightBetter(int[] arr) {
         int[] leftMaxArr = new int[arr.length];
         leftMaxArr[0] = arr[0];
         int[] rightMaxArr = new int[arr.length];
         rightMaxArr[arr.length - 1] = arr[arr.length - 1];
         for (int i = 1; i != arr.length; i++) {
            leftMaxArr[i] = Math.max(leftMaxArr[i - 1], arr[i]);
         }
         for (int i = arr.length - 2; i != -1; i--) {
             rightMaxArr[i] = Math.max(rightMaxArr[i + 1], arr[i]);
         }
         int max = 0;
         for (int i = 0; i != arr.length - 1; i++) {
             max = Math.max(max, Math.abs(leftMaxArr[i] - rightMaxArr[i + 1]));
         }
         return max;
     }
 
     public static int getMaxABSLeftAndRightBest(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]);
     }
 
 }

class Solution {
public:
 /**
 *	求左部分中的最大值减去右部分最大值的绝对值
 *	vec: 输入数组
     *  len vec的长度
 *	返回：左部分中的最大值减去右部分最大值的绝对值
 */
 int getMaxABSLeftAndRight(vector<int> data, int n) {
        int i,j=0;
        for(i=1;i<n;i++){//让j指向最大元素 
            if(data[i]>data[j]){
                j=i;
            }
        }

        int leftMax=data[0],rightMax=data[n-1];//尽量让这两个尽可能小
        for(i=1;i<j;i++){
            if(data[i]>=leftMax)
                break;
        } 
        for(i=n-2;i>j;i--){
            if(data[i]>=rightMax)
                break;
        }

        if(leftMax<rightMax)
              return abs(data[j]-leftMax);
        else
              return abs(data[j]-rightMax);

 }
};