两种方法求解 正数数组中 两个数相减 的最大值

一，问题描述

给定一个正数数组arr（即数组元素全是正数），找出该数组中，两个元素相减的最大值，其中被减数的下标不小于减数的下标。

即求出： maxValue = max{arr[j]-arr[i] and j >= i}

二，求解思路

下面采用两种不同的算法来求解，第一种算法的时间复杂度为O(N)，第二种算法的时间复杂度为O(N^2)。

算法一思路如下：（初始时减数为arr[0]，然后算法不断记录比当前减数更小的减数）

maxValue初始化为0，因为当 i==j 时，arr[j] - arr[i] = 0，故 maxValue的值不可能为负数。

因此将下标 i 初始化为0，j 从下标1处开始向后扫描，并计算sub = arr[j]-arr[i]

若sub大于maxValue，则更新maxValue的值。

否则，若sub小于0，意味着找到一个新的数组元素，该数组元素比 arr[i]的值要小，则更新下标 i.

为什么这样可以？

因为：当计算 sub = arr[j]-arr[i]时，arr[i]越小，则得到的sub越大。而下标 i 不断标记更小的减数，后面的元素arr[j]与 更小的减数相减才能得到更大的差值。

比如，下图所示数组：

 

arr[0]=18，当j=2时，max=arr[2]-arr[0]=8。当遍历到arr[3]=12时，由于12小于18，故把下标 i 由 0 更新为 3。不需要”关注“下标为1和2的这两个元素。因为，

若在 j>3 后面有元素使得 arr[j]-arr[1] 或者 arr[j]-arr[2]>maxValue，则该arr[j]-arr[0]一定比 arr[j]-arr[1]更大，因为arr[1]和 arr[2]都比arr[0]大。

同理：也不需要关注元素值为12 和 元素值为10之间的元素，因为，若后面某个元素减去某个 “12 到 10之间的元素（16、18、22）”比maxValue大，那么它减去12一定更大。

这样，下标 i 记录的总是下一个比 arr[i] 更小的值（这有点类似于贪心算法的味道，每次总是贪比当前值更小的一个值），而不是如算法2中那样依次遍历数组中的每个元素。

代码如下：

    //算法复杂度O(N). 找出数组arr中两个数相减的最大值
    public static int maxValueOfSubtraction(int[] arr){ 
        int max = 0;// when j == i
        int i = 0;
        int sub;
        for(int j = 1; j < arr.length; j++){
            sub = arr[j] - arr[i];
            if(sub > max)
                max = sub;
            else if(sub < 0)//means there is a number smaller than a[i](i initial value is 0)
                i = j;
        }
        return max;
    } 

算法二：

就是一个很普通的方法。求出 数组中所有下标大的元素减去下标小的元素，找出其中的最大值即可。代码如下：

    //O(N^2) 找出数组arr中两个数相减的最大值
    public static int maxValueSub(int[] arr){
        int max = 0;
        int sub;
        for(int i = 0; i < arr.length; i++){
            for(int j = i+1; j < arr.length; j++){
                sub = arr[j] - arr[i];
                if(sub > max)
                    max = sub;
            }
        }
        return max;
    }

一个错误的解法：

由于题目中要求的是 被减数的下标要大于减数的下标，故下面解法是错误的：

依次扫描数组中的每个元素，找出数组元素中的最大值和最小值。最大值减去最小值 即为两个元素相减的最大值。

错误的原因是：最大值元素的下标 可能 比 最小值元素的下标要小。

错误解法代码如下：

    public static int maxValueSub3(int[] arr){
        int min, max;
        int indexM = -1;int indexm = -1;
        min = max = arr[0];
        for(int i = 1; i < arr.length; i++){
            if(arr[i] > max)
            {
                max = arr[i];
                indexM = i;
            }
            else if(arr[i] < min){
                min = arr[i];
                indexm = i;
            }
        }
        System.out.println("indexM" + indexM + " indexm:" + indexm);
        return max - min;
    }

三，运行时间的比较

采用 这篇文章 中提到的随机数生成算法 来随机生成一个数组，然后比较上面两个算法的运行时间。

机器环境如下：

OS:win7 64bit、RAM:6GB、CPU:Pentium(R)Dual-Core E5800@3.2GHz

时间比较如下：

数组大小        算法1运行时间       算法2运行时间

100*100               1                        61

200*100               3                        158

400*100               2                        568

500*100               2                        878

100*100*10         4                        3451

整个代码如下：

/*
 * given an array, find out the max value of two numbers's distraction.
 * max{a[j]-a[i]} under the condition of j>=i
 */
public class MaxValue {
    
    //算法复杂度O(N). 找出数组arr中两个数相减的最大值
    public static int maxValueOfSubtraction(int[] arr){ 
        int max = 0;// when j == i
        int i = 0;
        int sub;
        for(int j = 1; j < arr.length; j++){
            sub = arr[j] - arr[i];
            if(sub > max)
                max = sub;
            else if(sub < 0)//means there is a number smaller than a[i](i initial value is 0)
                i = j;
        }
        return max;
    } 
    
    //O(N^2) 找出数组arr中两个数相减的最大值
    public static int maxValueSub(int[] arr){
        int max = 0;
        int sub;
        for(int i = 0; i < arr.length; i++){
            for(int j = i+1; j < arr.length; j++){
                sub = arr[j] - arr[i];
                if(sub > max)
                    max = sub;
            }
        }
        return max;
    }
    
    
    public static void main(String[] args) {
        int[] arr = C2_2_8.algorithm3(100*100*10);

        long start = System.currentTimeMillis();
        int r = maxValueOfSubtraction(arr);
        long end = System.currentTimeMillis();
        System.out.println("maxValue=" + r + "  O(N)'s time:" + (end -start));
        
        long start2 = System.currentTimeMillis();
        int r2 = maxValueSub(arr);
        long end2 = System.currentTimeMillis();
        System.out.println("maxValue=" + r2 + "  O(N^2)'s time:" + (end2 - start2));
    }
}