Java 查找数组中第二大偶数int的有效方法

赋值是创建一个方法，该方法在整数数组中查找第二大偶数整数。我被限制使用任何库中的任何方法

以下是适用于所有情况的代码：

public static int getSecondLargestEven(int[] ary) {


int i;

    aryLength = ary.length;
    int largestEven = -1;
    int secondLargestEven = -1;

    for (i = 0; i < aryLength; i++) {
        if (ary[i] % 2 == 0) {
            if (ary[i] > largestEven) {
                if (largestEven != -1)
                    secondLargestEven = largestEven;

                largestEven = ary[i];
            } else { 
                if (ary[i] != largestEven) {
                    if (secondLargestEven == -1 || ary[i] >= secondLargestEven) {
                        secondLargestEven = ary[i];
                    }
                }
            }
        }
    }

public static int getsecondlargest偶数（int[]ary）{
int i；
aryLength=ary.length；
int最大偶数=-1；
int次最大偶数=-1；
对于（i=0；i最大偶数）{
如果（最大偶数！=-1）
第二大偶数=最大偶数；
最大偶数=三元[i]；
}否则{
if（ary[i]！=最大偶数）{
if（次最大偶数==-1 | |元[i]>=次最大偶数）{
第二大偶数=第三[i]；
}
}
}
}
}

在调用方法之前，我要求数组具有多个甚至没有方法调用的方法。 所以，当Secondlargest偶数==-1时，我知道有一个重复项

是否有一种更有效的方法（更少地使用运算符，更少地使用循环，更少地分配内存）来实现这一目标？如何改进代码的逻辑？如何全面改进代码？

---

我不喜欢这样，我必须将幻数-1分配给secondlargest偶数和largest偶数，因为它们在技术上被命名为保持偶数。使用循环将数组中的有效偶数分配给secondlargest偶数和largest偶数，然后继续搜索是否有效？提前感谢。

您可以通过当

最大

和

第二个

变量等于

-1

时，未明确检查是否存在这种情况

只需在循环之前将这些变量设置为

Integer.MIN\u VALUE

，这与假设数组中有两个附加值在所有其他值之前，并且它们都具有值

Integer.MIN\u VALUE

public static int secondLargestEven(int[] x) {

    int largest = Integer.MIN_VALUE;
    int second = Integer.MIN_VALUE;

    for (int i = 0; i < x.length; i++) {
        if (x[i] % 2 == 0) {
            if (x[i] > largest) {
                second = largest;
                largest = x[i];
            } else if (x[i] > second) {
                second = x[i];
            }
        }
    }

    return second;

}

---

只是一个有趣的想法…在Haskell中，这个函数可以写在一行中

import Data.List (sort)

secondLargestEven = (!! 1) . reverse . sort . filter even

或者，如果你想更有效率

import Data.List (sortBy)
import Data.Ord  (comparing)

secondLargestEven = (!! 1) . sortBy (comparing negate) . filter even

---

当

最大值

和

第二值

变量等于

-1

时，您可以通过不显式检查大小写来使代码更干净

只需在循环之前将这些变量设置为

Integer.MIN\u VALUE

，这与假设数组中有两个附加值在所有其他值之前，并且它们都具有值

Integer.MIN\u VALUE

public static int secondLargestEven(int[] x) {

    int largest = Integer.MIN_VALUE;
    int second = Integer.MIN_VALUE;

    for (int i = 0; i < x.length; i++) {
        if (x[i] % 2 == 0) {
            if (x[i] > largest) {
                second = largest;
                largest = x[i];
            } else if (x[i] > second) {
                second = x[i];
            }
        }
    }

    return second;

}

---

只是一个有趣的想法…在Haskell中，这个函数可以写在一行中

import Data.List (sort)

secondLargestEven = (!! 1) . reverse . sort . filter even

或者，如果你想更有效率

import Data.List (sortBy)
import Data.Ord  (comparing)

secondLargestEven = (!! 1) . sortBy (comparing negate) . filter even

---

这只是为了好玩的实现：

public static int secondLargestEven(int[] array) {

    Set<Integer> evenSet = new TreeSet<>(Collections.reverseOrder());
    for (int n : array) if (n % 2 == 0) evenSet.add(n);
    return new ArrayList<>(evenSet).get(1);
}

公共静态int次最大偶数（int[]数组）{
Set evenSet=新树集（Collections.reverseOrder（））；
如果（n%2==0）evenSet.add（n），则为（int n:array）；
返回新的ArrayList（evenSet）.get（1）；
}

此方法效率极低（我看不出来），但返回第二大偶数：）

---

只有当数组有第二大偶数时，方法才起作用。

这只是为了好玩的实现：

public static int secondLargestEven(int[] array) {

    Set<Integer> evenSet = new TreeSet<>(Collections.reverseOrder());
    for (int n : array) if (n % 2 == 0) evenSet.add(n);
    return new ArrayList<>(evenSet).get(1);
}

公共静态int次最大偶数（int[]数组）{
Set evenSet=新树集（Collections.reverseOrder（））；
如果（n%2==0）evenSet.add（n），则为（int n:array）；
返回新的ArrayList（evenSet）.get（1）；
}

此方法效率极低（我看不出来），但返回第二大偶数：）

---

---

只有当数组有第二大偶数时，方法才起作用。

如果愿意，您可以用

-2147483648

替换

Integer.minu VALUE

，但在我看来，它使代码不那么清晰：）快速问题：将x.length指定给int类型的某个变量是否更有效，这样我就不会调用.length（）每次循环迭代？不，因为

length

是数组的一个特殊属性，而不是一个方法，所以您不会产生方法调用开销。看到这个答案-我从来没有想过。感谢分享！如果您愿意，您可以用

-2147483648

替换

Integer.MIN\u VALUE

，但我认为这会减少代码开销ear:）快速问题：将x.length分配给int类型的变量是否更有效，这样我就不会调用.length（）每次循环迭代？不，因为

length

是数组的一个特殊属性，而不是一个方法，所以不会产生方法调用开销。请看这个答案-我从来没有想过。感谢分享！感谢您希望改进的工作代码（运行时、资源或通用样式/体系结构），您将得到最好的服务。就性能而言，您的代码似乎是高效的，即使它不好。代码优雅和最佳效率通常是incompatible@Joel我认为，在大多数情况下，渐进效率与优雅是非常兼容的。现在使用更少的1字节可能会产生难看的代码。感谢您查看我的代码！这是这个问题似乎离题了，因为关于最佳实践和性能的问题属于您希望改进的工作代码（运行时、资源或通用样式/体系结构），您将得到最好的服务。就性能而言，您的代码似乎是高效的，即使它不好。代码优雅和最佳效率通常是incompatible@Joel我认为，在大多数情况下，渐进效率与优雅是非常兼容的。现在使用更少的1字节可能会产生难看的代码。感谢您查看我的代码！这是这个问题似乎离题了，因为有关最佳实践和性能的问题属于