Java 在较早出现较小整数的数组中查找可能的最大差异

这是一个采访问题：

查找整数数组中可能存在的最大差异，以便较小的整数出现在数组的前面

约束条件： 数字不是唯一的。 范围是java的整数范围。（或任何其他语言）

例如：

输入1:{1100,2105，-10,30100}

最大的差异在-10和100->110之间（这里-10是第5个索引，100是第7个索引）

输入2:{1100,2105，-10,30,80}

最大的差异在1和105->104之间（这里1是第一个索引，105是第四个索引）

可能的解决办法：

一种方法是检查所有可能的差异，并跟踪到目前为止发现的最大差异O（n^2）复杂性

---

这能在比O（n^2）更好的时间内完成吗

我很确定这会解决你的问题：

    int largestNumber = Integer.MIN_VALUE;
    int smallestNumber = Integer.MAX_VALUE; 

    for(int i = 0; i < yourArray.Length; i++)
    {
        if(yourArray[i] > largestNumber)
            largestNumber = yourArray[i];

        if(yourArray[i] < smallestNumber)
            smallestNumber = yourArray[i];

    }

    int biggestDifference = largestNumber - smallestNumber ;

int largestNumber=Integer.MIN_值；
int smallestNumber=Integer.MAX_值；
for（int i=0；ilargestNumber）
最大数=数组[i]；
if（你的数组[i]

从最后一个元素开始，然后向后移动。请记住迄今为止出现的最大元素。 对于每个元素，从最大值中减去并存储在相应位置

此外，您可以保留一个元素来存储最大差异，并立即给出输出。 O（n）时间，O（1）空间

int max=int\u MIN；
int-maxdiff=0；
对于（i=sizeof（arr）/sizeof（int）-1；i>=0；i--）{
如果（最大值

我建议最大的差异总是在之前最大的数字和最小的数字之间，或者在之后最小的数字和最大的数字之间。这些可以在线性时间内确定

Dhandeep的算法很好，Vivek将代码翻译成Java很有效！ 此外，我们还可以正常扫描阵列，而不是反向扫描：

int seed[] = {1, 100, 2, 105, -10, 30, 100};
int maxDiff=Integer.MIN_VALUE, minNumber = Integer.MAX_VALUE;

for (int i = 0; i < seed.length ; i++){
    if(minNumber > seed[i]) 
       minNumber = seed[i];

    maxDiff = Math.max(maxDiff, (seed[i]-minNumber));
}
System.out.println(maxDiff);

int seed[]={1100,2105，-10,30100}；
int maxDiff=Integer.MIN\u值，minNumber=Integer.MAX\u值；
for（int i=0；iseed[i]）
minNumber=种子[i]；
maxDiff=Math.max（maxDiff，（seed[i]-minNumber））；
}
System.out.println（maxDiff）；
谢谢@Dhandeep Jain的回答。以下是java版本：

//int seed[] = {1, 100, 2, 105, -10, 30, 100};
        int seed[] = {1, 100, 2, 105, -10, 30, 80};
        int maxDiff=Integer.MIN_VALUE, maxNumber = Integer.MIN_VALUE;

        for (int i = (seed.length-1); i >=0 ; i--){
            if(maxNumber < seed[i]) 
                maxNumber = seed[i];

            maxDiff = Math.max(maxDiff, (maxNumber - seed[i]));
        }
        System.out.println(maxDiff);

//int seed[]={1100,2105，-10,30100}；
int seed[]={1100,2105，-10,30,80}；
int maxDiff=Integer.MIN\u值，maxNumber=Integer.MIN\u值；
对于（int i=（seed.length-1）；i>=0；i--）{
if（maxNumber<种子[i]）
maxNumber=种子[i]；
maxDiff=Math.max（maxDiff，（maxNumber-seed[i]）；
}
System.out.println（maxDiff）；
公共类测试{
公共静态void main（字符串[]args）{
int arr1[]={1,2,5,7,9}；
int arr2[]={20,25,26,35}；
int-diff=0；
int max=0；
for（int i=0；i
//解决方案复杂性：O（n）
intmaxdiff（inta[]，intn）{
//找出相邻元素的差异
内部差异[n+1]；
对于（int i=0；i0）diff[i]+=diff[i-1]；
如果（max_diff
首先查找数组相邻元素之间的差异，并将所有差异存储在大小为n-1的辅助数组diff[]中。现在，这个问题转化为查找此差异数组的最大和子数组。
公共静态void finddifence（整数arr[]）{
public static void findDifference(Integer arr[]) {
    int indexStart = 0;
    int indexMin = 0;
    int indexEnd = 1;
    int min = arr[0];
    int diff = arr[1] - arr[0];
    for (int counter = 1; counter < arr.length; counter++) {
        if (arr[counter] - min > diff) {
            diff = arr[counter] - min;
            indexEnd = counter;
            indexStart = indexMin;
        }
        if (arr[counter] < min) {
            min = arr[counter];
            indexMin = counter;
        }
    }
    System.out.println("indexStart = " + indexStart);
    System.out.println("indexEnd = " + indexEnd);
    System.out.println("diff = " + diff);
}

int indexStart=0；
int indexMin=0；
int indexEnd=1；
int min=arr[0]；
int diff=arr[1]-arr[0]；
用于（int计数器=1；计数器差异）{
diff=arr[计数器]-min；
indexEnd=计数器；
indexStart=indexMin；
}
if（arr[计数器]
Ruby解决方案：

a = [3, 6, 8, 1, 5]
min = 10**6
max_diff = -10**6
a.each do |x|
  min = x if x < min
  diff = x - min
  max_diff = diff if diff > max_diff
end
puts max_diff

a=[3,6,8,1,5]
最小值=10**6
最大差值=-10**6
a、 每个do | x|
如果x最大差异，则最大差异=差异
结束
最大差异
公共静态void findlargestDifference（int arr[]）{
int max_diff=0；
int min_值=Integer.min_值；
对于（int i=0；它不考虑较早出现的较小整数，因为您缺少“因此较小整数在数组中较早出现”问题的一部分。哦，对不起，我不敢相信我没有看到。我当时在手机上，我一定已经滚动过它了。：/在额外空间和复杂性方面有什么限制，如果有的话？对于那些感兴趣的人来说，O（n）之后的任何子阵列都有一个O（logn）解决方案使用段树进行预计算。如果您需要回答有关同一数据集的许多查询，则此操作非常方便。@alfasin否。您可以尝试使用SOP吗？我没有给出可以复制粘贴并运行的代码，我已经给出了逻辑。您可以用任何语言实现。虽然它偏向于cpp。请参阅，它跟踪了迄今为止最大的数字（从上一个开始）并找到每个循环的差异，动态更新最大值（如果它找到更大的最大值）。它还跟踪最大差异。我将您的循环固定为
I--
而不是
I++    // Solution Complexity : O(n)   
    int maxDiff(int a[], int n){
        //  Find difference of adjacent elements
        int diff[n+1];
        for (int i=0; i < n-1; i++)
            diff[i] = a[i+1] - a[i];

        // Now find the maximum sum sub array in diff array
        int max_diff = diff[0];
        for (int i = 1 ; i < n-1 ; i++ ) {
            if( diff[i-1] > 0 ) diff[i] += diff[i-1];
            if( max_diff < diff[i] ) max_diff = diff[i];
        }
        return max_diff;
    }

public static void findDifference(Integer arr[]) {
    int indexStart = 0;
    int indexMin = 0;
    int indexEnd = 1;
    int min = arr[0];
    int diff = arr[1] - arr[0];
    for (int counter = 1; counter < arr.length; counter++) {
        if (arr[counter] - min > diff) {
            diff = arr[counter] - min;
            indexEnd = counter;
            indexStart = indexMin;
        }
        if (arr[counter] < min) {
            min = arr[counter];
            indexMin = counter;
        }
    }
    System.out.println("indexStart = " + indexStart);
    System.out.println("indexEnd = " + indexEnd);
    System.out.println("diff = " + diff);
}

a = [3, 6, 8, 1, 5]
min = 10**6
max_diff = -10**6
a.each do |x|
  min = x if x < min
  diff = x - min
  max_diff = diff if diff > max_diff
end
puts max_diff

public static void findlargestDifference(int arr[]){

    int max_diff=0;     
    int min_value=Integer.MIN_VALUE;        
    for(int i=0;i<arr.length;i++){

        if(min_value<arr[i]){               
            min_value=arr[i];               
        }           
        int diff=min_value-arr[i];

        if(max_diff<diff){
            max_diff=diff;
        }                   
    }       
    System.out.println("Max Difference is  "+ max_diff);    
}