数组中元素差的最大值

这道题是2016美团面试题：

1.给定一个数组arr，数组长度为len，求满足 0 <= a <= b < len的 arr[b] - arr[a]最大值。

你的想法：让每一个数字减去它右边的数字，并通过比较得到数对的最大值，时间复杂度（O^2）,这应该是面试官不想要的。

解法一：分治法(递归实现)

假设把数组分成两个子数组，用左数组最大的减去右数组最小的，最大值有三种情况：

　　(1)被减数和减数都在第一个子数组中，即第一个子数组中的数对之差的最大值；

　　(2)被减数和减数都在第二个子数组中，即第二个子数组中数对之差的最大值；

　　(3)被减数在第一个子数组中，是第一个子数组的最大值；减数在第二个子数组中，是第二个子数组的最小值。

（1）、（2）、（3）中，这三个差值的最大者就是整个数组中数对之差的最大值。

 

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
// 解法1： 分治法（递归实现）
int Max_Find(int *s,int *e,int *max,int *min)
{
    if(s >= e)
    {
        *max = *min = *s;
        return -1;
    }
    int *mid = s+(e-s)/2;

    int maxleft,minleft;
    int left = Max_Find(s,mid,&maxleft,&minleft);

    int maxright,minright;
    int right = Max_Find(mid+1,e,&maxright,&minright);

    int sum = maxleft - minright;

    *max = (maxleft > maxright) ? maxleft:maxright;
    *min = (minleft < minright) ? minleft:minright;

    int m = (left > right) ? left:right;

    m = (m > sum)?m:sum;

    return m;
}
int MaxDiff(int array[], unsigned int len)
{
    if(NULL == array || len < 2){
        return -1;
    }
    int max, min;
    int MaxDiff_Num = Max_Find(array, array+len-1, &max, &min);
    printf("maxDiff_Num: %d

", MaxDiff_Num);
}

int main()
{
    int a[2] = {10,5};
    MaxDiff(a,2);
}

 

解法二：转化为求数字数组最大和问题。

参考：这里

使用一个辅助数组arr2，则arr2[i] = arr[i] - arr[i+1]

即：arr2中从i加到j，arr2[i] + arr2[i+1]+.....+arr2[j]

则：(arr[i]-arr[i+1])+(arr[i+1]-arr[i+2])+....(arr[j]-arr[j+1])

转化为arr[i]-arr[j+1]

#include <iostream>
#include <stack>
#include <algorithm>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
using namespace std;
int max_find(int arr[],int len)
{
    if(arr == NULL || len < 2)
    {
        return -1;
    }
    int *arr2 = new int[len - 1];
    int i = 0;
    for(i = 0;i < len-1;++i)
    {
        arr2[i] = arr[i] - arr[i+1];
    }
    int curS = 0;
    int max = -1;
    for(i = 0;i < len-1;++i)
    {
        if(curS <= 0)
        {
            curS = arr2[i];
        }else
        {
            curS +=arr2[i];
        }
        if(curS > max)
        {
            max = curS;
        }
    }
    if(arr2)
    {
        delete [] arr2;
        arr2 = NULL;
    }
    printf("%d",max);
}
int main()
{
    int a[2] = {10,5};
    max_find(a,2);
}

解法三：动态规划法

依次遍历数组用arr[i-1]之前的最大 值减去右边的元素

#include <iostream>
#include <stack>
#include <algorithm>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
using namespace std;
int max_find(int arr[],int len)
{
    if(arr == NULL || len < 2)
    {
        return -1;
    }
    int max = arr[0];
    int sum = max - arr[1];//初始化数对差
    int i = 0;
    for(i = 2;i < len;++i)
    {
        if(arr[i-1] > max)
        {
            max = arr[i-1]; //左侧最大值
        }
        int cur = max - arr[i];//用最大的值减右侧的最小值
        if(cur > sum) //判断是否是最大数对之差
        {
            sum = cur;
        }
    }
    printf("%d",sum);
}
int main()
{
    int a[2] = {10,5};
    max_find(a,2);
}

以上三种都是O(n),那么：

第一种：递归，有递归栈

第二种：要n-1辅助数组

第三种：推荐