Java 最大增差

我需要找到向量中数字之间的最大递增距离或差值。例如，在向量

[10,5,20,45,5,5,7]

中，在第一次传递时，10和45之间的差异看起来是最大的。但在第二次迭代中，5和45之间的差异较大，因此应由算法选择

我有一个解，但它是O（n^2），就我的一生而言，我不知道是否有一个计算复杂度较低的解

public void maxDistance(int inputArray[]) {
    int trueMaxValue = 0,   trueMinIndex = 0,   trueMaxIndex = 0,  tempMaxValue;

    for (int i = 0; i < inputArray.length - 1; ++i) {
        for (int j = i + 1; j < inputArray.length; ++j) {
            tempMaxValue = inputArray[j] - inputArray[i];
            if (tempMaxValue > trueMaxValue) {
                trueMaxValue = tempMaxValue;
                trueMinIndex = i;
                trueMaxIndex = j;
            }
        }
    }
}

public void最大距离（int-inputArray[]{
int trueMaxValue=0，trueMinIndex=0，trueMaxIndex=0，tempMaxValue；
对于（int i=0；itrueMaxValue）{
trueMaxValue=tempMaxValue；
trueMinIndex=i；
trueMaxIndex=j；
}
}
}
}

---

我还需要知道最大值中使用了数组中的哪两个数字。您能帮忙吗？我只是不知道我是否应该继续思考，或者O（n^2）是你能做的最好的吗？

也许我遗漏了一些东西，但是：

• 迭代数组
• 确定最小的条目
• 确定最大的入口
• 计算增量（最大-最小）

---

所有这些都可以在一次迭代中完成。这将得到5和45，并给出40的差值。如前所述-仅通过一次。

这可以在线性时间内完成

以下是一个概要：

迭代数组，跟踪看到的最小数目 到目前为止

计算迄今为止看到的最小数字与当前数字之间的差值，并跟踪最大的差值

瞧。

你可以用O（n）Stephany来做。您需要添加一些变量来记住当前最佳解决方案是什么。使用当前的命名约定，可以执行以下操作：

    public void maxDistance(int inputArray[]) {
        int currentMin = inputArray[0],     currentMinIndex = 0;
        int trueMaxValue = 0,   trueMinIndex = 0,   trueMaxIndex = 0;
        int tempMaxValue;

        int i = 1;
        while (i < inputArray.length) {
            tempMaxValue = inputArray[i] - inputArray[currentMinIndex];
            if (tempMaxValue > trueMaxValue) {
                trueMaxValue = tempMaxValue;
                trueMinIndex = currentMinIndex;
                trueMaxIndex = i;
            }

            if (inputArray[i] < currentMin) {
                currentMinIndex = i;
                currentMin = inputArray[i];
            }

            ++i;
        }

public void最大距离（int-inputArray[]{
int currentMin=inputArray[0]，currentMinIndex=0；
int trueMaxValue=0，trueMinIndex=0，trueMaxIndex=0；
int-tempMaxValue；
int i=1；
while（itrueMaxValue）{
trueMaxValue=tempMaxValue；
trueMinIndex=当前最小索引；
trueMaxIndex=i；
}
if（输入阵列[i]

您肯定有更好的选择。我不确定为什么这里甚至需要嵌套循环。我将进行编辑以包含索引，但考虑到您的数组可能有重复的数字，我不确定为什么这对场景有帮助

int[] inputArray = new int[] {10,5,20,5,5,46,7};
int max = 0;
int min = Integer.MAX_VALUE;
for (int i = 0; i < inputArray.length; i++) {
    max = inputArray[i] > max ? inputArray[i] : max;
    min = inputArray[i] < min ? inputArray[i] : min;
}
int delta = max - min;

int[] inputArray = new int[] {10,5,20,5,5,46,7};
int max = 0;
int min = Integer.MAX_VALUE;
int maxIndex = -1;
int minIndex = -1;
for (int i = 0; i < inputArray.length; i++) {
    if (inputArray[i] > max) {
        max = inputArray[i];
        maxIndex = i;
    } 
    if (inputArray[i] < min) {
        min = inputArray[i];
        minIndex = i;
    }
}
int delta = max - min;

int[]inputArray=newint[]{10,5,20,5,5,46,7}；
int max=0；
int min=整数最大值；
for（int i=0；imax？输入阵列[i]：max；
min=输入阵列[i]

我将进行编辑以包含索引，但考虑到数组可能有重复的数字，我不确定这在这种情况下是否有用

int[] inputArray = new int[] {10,5,20,5,5,46,7};
int max = 0;
int min = Integer.MAX_VALUE;
for (int i = 0; i < inputArray.length; i++) {
    max = inputArray[i] > max ? inputArray[i] : max;
    min = inputArray[i] < min ? inputArray[i] : min;
}
int delta = max - min;

int[] inputArray = new int[] {10,5,20,5,5,46,7};
int max = 0;
int min = Integer.MAX_VALUE;
int maxIndex = -1;
int minIndex = -1;
for (int i = 0; i < inputArray.length; i++) {
    if (inputArray[i] > max) {
        max = inputArray[i];
        maxIndex = i;
    } 
    if (inputArray[i] < min) {
        min = inputArray[i];
        minIndex = i;
    }
}
int delta = max - min;

int[]inputArray=newint[]{10,5,20,5,5,46,7}；
int max=0；
int min=整数最大值；
int maxIndex=-1；
int minIndex=-1；
for（int i=0；imax）{
max=输入阵列[i]；
maxIndex=i；
} 
if（输入阵列[i]

请澄清：此方法的预期输出是什么？您正在给出一个示例，我的结论是：结果应该是40。（45和5之间的增量）。输出将是最大差值和位置（指数）在这两个数字中，贡献最大值的是：“

[10,5,50]

”的预期输出是什么？对于新手来说还是个好问题：-”

[10,5,50]

的预期输出是50-5或45。进一步澄清一下，如果数组是“

[10,50,5]

那么输出值应该是50-10或40，因为正如我在原始帖子中所写的那样，这一定是一个不断增大的差值，在这种情况下，从50到5的差值正在减小。谢谢，但是你的解决方案不记得索引。我也不喜欢三元运算符。我发现它们导致代码不清楚。这段代码不起作用，为什么你不先测试一下重新发布？变量“min”将永远不会更新。我真的很抱歉，希望您不要采取错误的方式。我只是认为发布的代码应该是正确的。但您仍然有一个错误。正确的语句是“Integer.MAX_VALUE”。在您发布正确的解决方案后，我将很高兴投票支持您。我尝试运行了您最新的代码并它不起作用。我认为你的循环没有考虑数组的最后一个元素。下面有一个更有效的答案…实际上有三个。这个答案非常慢。这种测试方法，从10整数扩展到1000万整数，运行时间是原来的两倍。我很乐意一次又一次地分享我的测试结果不管如何运行，您的速度仍然较慢。答案已编辑，因为您是正确的，min不应该从0开始。解决@anomeric注释：首先，教学法也很重要，我特意决定使用尽可能接近问题编写方式的代码流。其次，我认为您对性能的要求是我正在测试，所以我尝试了一下，在所有运行中，您都是错误的。100万个整数的运行时间最大差异是1毫秒（7和6毫秒）。1000万个整数的最大差异是3毫秒（16和13毫秒）。最后也是最重要的