兩種方法求解 正數數組中 兩個數相減 的最大值

一，問題描述

給定一個正數數組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));
    }
}