Anordnen der höchsten int in einem int[]

[Patrick_1991]

Hallo alle.

Ich würde gerne 2 Sachen wissen:
Wie bekomme ich aus einem int[] die 9 höchsten Variablen ?

int[] haupt = {45, 45, 0, 878, 45842, 87878, 8548, 1458, 8232};
int eins = // Soll aus dem int[] oben ausgelesen werden (ist die höchste).
// ... für weitere 8 Plätze (8te: Ist dann die zweit Höchste)

Diese sollen sich das also in jeder Variable befinden...

2.Frage ( nicht sehr wichtig nur wenn ihr es wisst ):

Wie kann ich aus einem String[] einen int[] machen,
natürlich enthält der String[] auch nur zahlen...

Mfg & vielen Dank im Voraus
Patrick

 

[Gast2]

1) Array sortieren und die ersten 9 Zahlen rausnehmen
2) int[] Array der selben Größe erzeugen, mit ner schleife durch das Array laufen und per Integer.parseInt die Zahlen konvertieren.

 

[Patrick_1991]

Vielen Dank erstmal ;-)

1) Verstehe ich immer noch nicht, weil es leider nicht ganz so simpel ist.
Ich weiß leider nicht wie groß UND aus wie vielen Elementen der Array besteht...
Trotzdem ne Idee ...

Mfg
Patrick

 

[Final_Striker]

Ich weiß leider nicht wie groß UND aus wie vielen Elementen der Array besteht...

Das spielt doch beim Sortieren keine Rolle.

EDIT:

Kannst aber auch 9 mal mit einer Schleife über das Array laufen und jeweils die größte Zahl rausnehmen.

 

[poku17]

Naja, das int-array initialisierst du einfach mit der Laenge des String-Arrays...
also:

int[] intArray = new int[stringArray.length];

und zum sortieren kannst du im dem Fall auch einfach die Utility-Class Arrays nehmen...

Arrays.sort(Array a);

aber selbst schreiben bringt dir mehr... eine Methode die dir ein int-array sortiert is auch echt garnicht schwierig...

nur kurz hier im Eitor gechrieben, kann Fehler enthalten... aber so waere mein ansatz...

public static void sortIntArray(int[] intArray){
  int tmpStart = intArray[0];
  for(int i = 1; i < intArray.length; i++){
    if(tmpStart < intArray[i]){
      intArray[i - 1] =  intArray[i];
      intArray[i] = tmpStart;
    }
    else{
      tmpStart = intArray[i];
    }
  }
}

oder eben rueckgabe type int[] und das sortierte array zurueckgeben lassen...

 

[Landei]

Man kann einen Bubble-Sort machen, der nach dem neunten Durchlauf abbricht.

 

[Marco13]

Bubble vertauscht ja nur... bei einem Array wie
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 8 9
würde erstmal die 8 (mit mehr als 9 Schritten) nach vorne wandern... Selection Sort, vielleicht!?

 

[Landei]

Ich meinte 9 äußere Schleifendurchläufe: Im ersten Durchlauf bubbelt das Maximum ganz nach hinten, im zweiten Durchlauf landet der zweitgrößte Wert auf dem vorletzten Platz u.s.w.

 

[Kababär]

Quick-Sort lautet hier das Stichwort. Wir haben das gerade in der Schule gemacht
Ist zwar am Kompleziertesten, aber dafür lohnt es sich!

Wieso ist ein selbst geschriebenes Programm schneller als die Utility-Class?

 

[hüteüberhüte]

...natürliche Ordnung wären aufsteigend sortierte Arrays. Ein BubbleSort, der nach dem n-ten Durchlauf abbricht, kann die größten n Zahlen entweder auf die letzten oder auf ersten Stellen tauschen.
Denkbar wäre auch ein Selection Sort, der die ersten/letzten n Zahlen richtig einsortiert:

int[] array = ...;

int i1 = 0; // zuerst kleinstes Element, dann größtes Element
for (int i = 0; i < array.length; i++) {
    if (array[i] > i1) {
        i1 = array[i];
    }
}

int i2 = 0; // zuerst kleinstes Element, dann zweitgrößtes Element
for (int i = 0; i < array.length; i++) {
    if (array[i] < i1 && array[i] > i2) {
        i2 = array[i];
    }
}


int i3 = 0; // drittgrößtes Element
for (int i = 0; i < array.length; i++) {
    if (array[i] < i2 && array[i] > i3) {
        i3 = array[i];
    }
}

// usw.

Habe einfach mal angenommen, dass hierbei zumindest 3 Elemente größer 0 sind und dass es keine gleichen Elemente gibt. Falls es doch gleiche Elemente gibt, so wird unter jeweils gleichen Elementen immer nur eins ausgewählt. Das lässt sich nicht umgehen.

Es kann auch Integer.MIN_VALUE verwendet werden.

 

[Patrick_1991]

Dankeschön für die Hilfe

 

[Marco13]

i1 bis i9 ... das ist doch bogus :autsch: Nimm ein sort, und wenn der Array zu groß ist, lauf 9 mal drüber und hol dir die höchsten Zahlen.

 

[pro2]

Hab hier höchstens noch eine Selectionsort Implementierung, die sich dafür ggf. anbieten würde:

    public static int[] getHighestNumbers(int[] array, int numbers)
    {
        int max = 0;
        int left = 0;
        int[] temp = new int[numbers];
        while(left < numbers)
        {
            max = left;
            for(int i = left + 1; i < array.length; i++)
            {
                if(array[i] > array[max])
                {
                    max = i;
                }
            }
            //Array[left] und Array[min] vertauschen, der Weg ist beliebig
            array[left] = array[left] + array[max] - (array[max] = array[left]);
            temp[left] = array[left];
            left++;         
        }
        return temp;
    }

 

[hüteüberhüte]

i1 bis i9 ... das ist doch bogus :autsch: Nimm ein sort, und wenn der Array zu groß ist, lauf 9 mal drüber und hol dir die höchsten Zahlen.

Wir kennen doch die Aufgabenstellung gar nicht. Wenn es wirklich 9 Variablen sein sollen ODER nicht das ganze Array sortiert sein muss ODER sie noch gar nicht verschachtelte Schleifen hatten ODER das Array nicht verändert werden soll ODER... ODER..., DANN bietet sich das einfach an. Think simple

 

[Landei]

Quick-Sort lautet hier das Stichwort. Wir haben das gerade in der Schule gemacht
Ist zwar am Kompleziertesten, aber dafür lohnt es sich!

Lohnt sich eben nicht, wenn nur ein paar Maximalzahlen benötigt werden. Merke: Wenn alles was man hat ein Hammer ist, sieht jedes Problem wie ein Nagel aus

 

[hüteüberhüte]

...ok, widmen wir uns nochmal diesem Problem und tragen alle Möglichkeiten zusammen (Kommentare im Code):

    public static void main(String[] args) {
        final int ARR_LENGTH = 1000;
        final int ARR2_LENGTH = 9;

        int[] array = new int[ARR_LENGTH];
        // mit zufälligen Zahlen füllen
        for (int i = 0; i < array.length; i++) {
            array[i] = (int) (Math.random() * ARR_LENGTH * 10.0);
            // 0 bis (ARR_LENGTH * 10 - 1)
        }


        // 1. Möglichkeit, mit zusätzlichem Array

        // kopieren...
        int[] arraySorted = java.util.Arrays.copyOf(array, array.length);

        // sortieren (imho Quicksort)...
        java.util.Arrays.sort(arraySorted);

        // größte Elemente finden...
        int[] array2 = new int[ARR2_LENGTH];
        for (int i = 0; i < array2.length; i++) {
            array2[i] = arraySorted[arraySorted.length - 1 - i];
        }

        // ausgeben...
        System.out.println(java.util.Arrays.toString(array2));


        // 2. Möglichkeit, modifizierter Selectionsort

        arraySorted = java.util.Arrays.copyOf(array, array.length);
        array2 = new int[ARR2_LENGTH];
        for (int i = 0; i < array2.length; i++) {
            int maxIndex = i;
            for (int j = i; j < arraySorted.length; j++) {
                if (arraySorted[j] > arraySorted[maxIndex]) {
                    maxIndex = j;
                }
            }
            int tmp = arraySorted[i];
            arraySorted[i] = arraySorted[maxIndex];
            arraySorted[maxIndex] = tmp;

            array2[i] = arraySorted[i];
        }

        // ausgeben...
        System.out.println(java.util.Arrays.toString(array2));


        // 3. Möglichkeit, Selectionsort, der das Array nicht verändert

        array2 = new int[ARR2_LENGTH];
        Set<Integer> indices = new HashSet<Integer>(array2.length);

        for (int i = 0; i < array2.length; i++) {
            int max = -1;
            int maxIndex = -1;
            for (int j = 0; j < array.length; j++) {
                if (!indices.contains(j) && array[j] > max) {
                    max = array[j];
                    maxIndex = j;
                }
            }
            array2[i] = max;
            indices.add(maxIndex);
        }

        // ausgeben...
        System.out.println(java.util.Arrays.toString(array2));


        // 4. Möglichkeit, wie Selectionsort, aber ggf. ungenau

        array2 = new int[ARR2_LENGTH];

        // erster Schritt...
        int max = -1;
        for (int i = 0; i < array.length; i++) {
            if (array[i] > max) {
                max = array[i];
            }
        }
        array2[0] = max;

        // zweiter Schritt...
        for (int i = 1; i < array2.length; i++) {
            max = -1;
            for (int j = 0; j < array.length; j++) {
                if (array[j] < array2[i - 1] && array[j] > max) {
                    max = array[j];
                }
            }
            array2[i] = max;
        }

        // ausgeben...
        System.out.println(java.util.Arrays.toString(array2));
    }

...dann ist die Ausgabe z.B.:

[9999, 9978, 9978, 9978, 9970, 9962, 9960, 9959, 9934]
[9999, 9978, 9978, 9978, 9970, 9962, 9960, 9959, 9934]
[9999, 9978, 9978, 9978, 9970, 9962, 9960, 9959, 9934]
[9999, 9978, 9970, 9962, 9960, 9959, 9934, 9897, 9870]

...hierbei sieht man, das über die dreifach vorkommende 9978 bei der letzten Möglichkeit einfach "hinweggegangen" wurde...

 

[hüteüberhüte]

BubbleSort wäre imho nicht schneller. Es ist die Frage, ob das Array verändert werden darf oder nicht. Dann könnte man jetzt noch Zeittestts durchführen -> Quicksort vs. modifizierten Selectionsort. Ab wie viel gesuchten Zahlen ist was schneller usw