Kehren die beiden größten ganzen zahlen in einem array von Werten

Schreiben Sie

public static int[] twoLargest(int values[]){
    int largestA = Integer.MIN_VALUE, largestB = Integer.MIN_VALUE;

    for(int value : values) {
        if(value > largestA) {
            largestB = largestA;
            largestA = value;
        } else if (value > largestB) {
            largestB = value;
        }
    }
    return new int[] { largestA, largestB }; 
}

public class Test
{

public static int[] findTwoHighestDistinctValues(int[] array)
{
    int max = Integer.MIN_VALUE;
    int secondMax = Integer.MIN_VALUE;
    for (int value:array)
    {
        if (value > max)
        {
            secondMax = max;
            max = value;
        }
        else if (value > secondMax && value < max)
        {
            secondMax = value;
        }
    }
    return new int[] { max, secondMax };
}

public static void main(String []args)
{
    int [] values = new int[5];
        values[0] = 5;
        values[1] = 10;
        values[2] = 15;
        values[3] = 20;
        values[4] = 25;
    int []ar = findTwoHighestDistinctValues(values);
    System.out.println("1 = "+ar[0]);
    System.out.println("2 = "+ar[1]);
}  
}

AUSGABE:

1 = 25

2 = 20

Übergeben, array mit Werten gefüllt werden:

public static void twoLargest(int [] values, int [] ret){
    //...
    ret[0] = largestA;
    ret[1] = largestB;
}


int [] ret = new int [2];
twoLargest(values, ret);
//now ret[0] is largestA
//and ret[1] is largestB

Nehme ich an, dass es Ihnen hilft, in Fall, dass Sie in der Lage sind, den größten, zweitgrößten, drittgrößten und so weiter von einer Funktion. Erstellt habe ich so eine :

public static int xLargest(int values[], int largeIndex)

Einfach das array übergeben und die largeIndex, für die größte send 1 , für die zweitgrößte senden 2 und so weiter.

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class XLargestIntArray {

    public static void main(String[] args) {

        int[] values = new int[5];

        values[0] = 5;
        values[1] = 10;
        values[2] = 15;
        values[3] = 20;
        values[4] = 25;

        System.out.println(xLargest(values,2));
        System.out.println();

    }

    public static int xLargest(int values[], int largeIndex) {

        List<Integer> intList = new ArrayList<Integer>();
        for (int index = 0; index < values.length; index++) {
            intList.add(values[index]);
        }
        Collections.sort(intList);
        return intList.get(intList.size() - largeIndex);
    }
}

Antwort von @Nilesh Jadav deckt alle Fälle ab. Antwort von @Peter Lawrey fehl in Fällen, in denen das array hat größten Wert das Letzte element ist. zum Beispiel [10,2,5,1,8,20] gibt 20 und 8 mit der akzeptierten Lösung.

Ausprobieren

int [] array1={10,2,5,1,8,20};

int largest= array1[0];

int seclargest=array1[0];

for (int i=1;i<array1.length;i++)
{
    if(largest <= array1[i])
    {
        seclargest=largest;
        largest=array1[i];  
    }   

}

System.out.println("largest and second largest are:" +largest + " " +seclargest);

   //Java8&9 makes this easier with a cleaner code
   int[] numbers = new int[]{1, 2, 5, 4, 57, 54, 656, 4};       
    int maxSize = 2;
    Arrays.stream(numbers) //stream
    .boxed()  //to Integer Object
    .sorted(Comparator.reverseOrder()) //sorted
    .limit(maxSize )  //keep N values
    .forEach(System.out::println); 

NB. Wir konnte dieses astuce mit bean-Objekt der Durchführung vergleichbarer oder durch Verwendung der betreffenden benutzerdefinierte Komparator.

Wenn die Leistung ist nicht ein Problem hier, das sollte es nicht sein, auf kleinen arrays, das getan werden könnte, mit weniger code.

Die einfachste Lösung ist, einfach Sortieren Sie das array und gibt die Letzte und vorletzte Wert:

public static int[] twoLargest(int[] values) {
    Arrays.sort(values);
    return new int[]{values[values.length - 1], values[values.length - 2]};
}

Die Zeit, die Komplexität der obige code ist O(n log (n)), wie dies in der Javadoc für - Arrays.sort():

Umsetzung Hinweis: Die Sortier-Algorithmus ist ein Dual-Pivot-Quicksort von Vladimir Yaroslavskiy, Jon Bentley, und Joshua Bloch. Dieser Algorithmus bietet O(n log(n)) die performance bei vielen Daten-sets, die dazu führen, dass andere quicksorts zu degradieren zu quadratischen Leistung und ist in der Regel schneller als herkömmliche (one-pivot) Quicksort-Implementierungen.

Wenn die erwartete Eingabe ist ein array mit weniger als zwei Elemente, eine Fehlerbehandlung muss Hinzugefügt werden, wie das werfen einer Ausnahme.