Question

因此，我创建了一个名为max2的方法，该方法应该返回数组中的2个最大值。我能够返回最高值，但是我不知道如何返回第二高值。

这是我的代码：主要方法

    public static void main(String[] args) {
        Integer intArray[] = { 13, 25, 46, 65, 12, 23};
        Double doubleArray[] = {1.2, 3.4, 1.1, 0.1, 5.6};
        String stringArray[] = {"H", "E", "L", "L", "O"};

    System.out.println("The smallest number is: " + myMin(doubleArray));
    System.out.println("The median is: " + median(doubleArray));
    System.out.println("The median is: " + median(stringArray));
    System.out.println("The max is: " + max2(intArray));
}

我的max2方法：

public static <E extends Comparable<E>> E max2(E... elements) {

Arrays.sort(elements);

    E max = elements[0];
    for (E element : elements) {
        if (element.compareTo(max) > 0) {
            max = element;

        }
    }
    return max;

}

我想知道是否有办法获取数组的倒数第二个索引。理想情况下，我希望它可以与任何数组一起使用。我希望被指出正确的方向。谢谢您的帮助。

Answer 1

您可以使用Java 8流删除重复项并对数组进行排序，并使用length-1和length-2从数组中获取最大和第二个最大元素

Integer intArray[] = { 13,13, 25, 46,25, 65, 12, 23};
    Double doubleArray[] = {1.2, 3.4, 1.1, 0.1, 5.6};
    String stringArray[] = {"H", "E", "L", "L", "O"};

   Integer[] s= Arrays.stream(intArray).sorted().distinct().toArray(Integer[]::new);
   System.out.println(Arrays.toString(s));
   int max = s[s.length-1];
   int max2 = s[s.length-2];

或者，如果您只想对数组进行排序，则应使用Arrays.sort对数组进行排序并获取max和second max元素

Arrays.sort(intArray) 
int max = s[s.length-1];
int max2 = s[s.length-2];

Answer 2

没有java-8，您可以使用以下逻辑简单地实现相同的目的。请注意，这对于查找任何数字的最大和第二个数字将非常有效。

for (int num : nums) {
   if (num > high1) {
     high2 = high1;
     high1 = num;
   } else if (num > high2) {
     high2 = num;
   }
}

要对String[]进行排序，可以对其进行排序，然后相应地找到索引

Arrays.sort(stringArray);
System.out.println(stringArray[stringArray.length - 1]);
System.out.println(stringArray[stringArray.length - 2]);

Answer 3

我们需要按降序对数组进行排序，然后才能使用冒泡排序，现在我们可以将最后一个索引值作为最高编号，将倒数第二个索引作为第二最高编号。例子。

class ReturnTwoHeighestNumber {
  public static void main(String...args) {
   int arr[] = {12,13,15,6,9,30,50,19};
   ReturnTwoHeighestNumber number = new ReturnTwoHeighestNumber();
   number.bubleSort(arr);
   number.printTwohighestNumber(arr)   
  }
  void bubleSort(int arr[]) {
  int n= arr.length;
   for(int i=0; j<n-1;i++) {
      for(int j=0;j<n-i-1; j++) {
         if(arr[j]> arr[j+1]) {
          int temp = arr[1];
          arr[j] = arr[j+1];
          arr[j+1] = temp;
         }
      }
   }
  void printTwohighestNumber(int arr[]) {
    int n= arr.length;
    for(int j=0;j<n;++j) {
      System.out.print(arr[j]+" ");
      System.out.println();  
    }
     System.out.println("My first highest Number is "+ arr[arr.length-1]);
     System.out.println("My Second highest Number is "+arr[arr.length-2]);   
  }    

  } 
}

Answer 4

您的方法

您当前的方法没有多大意义。你有

Arrays.sort(elements);

E max = elements[0];
for (E element : elements) {
    if (element.compareTo(max) > 0) {
        max = element;
    }
}
return max;

也就是说，您首先对数组进行排序。然后遍历所有元素以找到 max 元素。首先，您想找到第二个元素而不是max元素。其次，为什么在不利用已排序的事实而只是遍历数组的情况下进行排序呢？

让我为您展示一些解决方案。

完整排序

最简单的解决方案可能是先进行完整排序，然后访问倒数第二个元素（默认情况下，元素按升序排序）：

Arrays.sort(values);
return values[values.length - 2];

这种方法存在一个问题。 Arrays.sort对给定的数组进行内联排序。也就是说，它会更改您的输入数组。您可能不希望这样，而只想对副本进行排序。所以：

E[] copyValues = values.clone();
Arrays.sort(copyValues);
return copyValues[copyValues.length - 2];

部分排序

代替完全排序，您总是可以进行部分排序（k-sort）。这样会更快，因为您只需要对2个元素降序排列。您可以使用PriorityQueue进行部分排序。将所有元素插入队列，然后调用poll两次。队列总是根据顺序为您提供下一个元素。

PriorityQueue<E> queue = new PriorityQueue<>(Comparator.reverseOrder());
queue.addAll(Arrays.asList(values);

queue.poll(); // Greatest element
return queue.poll(); // Second to greatest element

迭代

最快的解决方案可能是进行一次普通迭代并记住最大的元素，以及第二至最大的元素。这类似于您的方法中的循环，但包括记住倒数第二个元素。

E max = values[0];
E secondMax = values[0];

for (E element : elements) {
    if (element.compareTo(max) > 0) {
        secondMax = max;
        max = element;
    } else if (element.compareTo(secondMax) > 0) {
        secondMax = element;
    }
}

return secondMax;

请注意，您还需要记住max元素，因为您希望找到一个不大于max但仍然大于其余元素的元素。

打印数组中的2个最高数字

4 个答案:

您的方法

完整排序

部分排序

迭代