Codeerklärung benötigt

[Ruderer1993]

Hallo,
ich habe hier einen Selection Sort Algorithmus, den ich vorgegeben bekommen habe. Mein Programm funktioniert einwandfrei aber ich versuche trotzdem den Code zu verstehen, was mir nicht gelingen will.
Für alle diejenigen die nicht wissen wie der Selection Sort Algorithmus funktioniert:
Selectionsort

Dies ist mein Code:

public static void selectionSort(int[] x) {
        for (int i = 0; i < x.length - 1; i++) { //Man benötigt genau x.length -1 Durchläufe
            int minIndex = i;      // Index des momentanen kleinsten Wertes
            for (int j = i + 1; j < x.length; j++) { //Index wird um eins erhöht, wenn die Zahl an dem Index kleiner ist, als die Größe des Arrays erhöhe weiter,sodass er alle Zahlen durchgeht
                if (x[minIndex] > x[j]) { //Falls  das momentane Minimum kleiner ist als die Zahl am Index j
                    minIndex = j;  //Dann Speichere den Index des neuen minimalen Wertes
                }
            }
            if (minIndex != i) { //Falls der Index des minmalen Wertes nicht dem alten entspricht, also wenn ein neues Maximum gefunden wurde, dann
                //Tausche den Wert mit dem kleinsten verfügbaren Wert per Dreieckstausch
                int temp = x[i];
                x[i] = x[minIndex];
                x[minIndex] = temp;
            }
        }
    }

Sind die Kommentare richtig, also habe ich es richtig verstanden ?!
Danke !

 

[Ruderer1993]

Hm keiner eine Antwort für mich parat ?

 

[Michael...]

Ich unterstelle mal, dass Du den Code grundsätzlich verstanden hast. Allerdings würde ich mir die Kommentare nochmal anschauen.

 

[Ruderer1993]

Ich schätze du meinst, das ich das Wort Index falsch einsetzte ? Ich meinte dann eigentlich j aber schrieb Index...
Oder ist es etwas anderes 😉 ?

 

[Ruderer1993]

bzw ist das Wort "momentane Minimum" irreführend weil es nicht der kleinste momentane Wert, sondern der kleinste momentane Index ist, richtig ?

 

[ralfgc]

Die Kommentare klingen für mich wie eine Übersetzung Java->Deutsch.
Was'n das für eine Aufgabe? Wenn das Ziel ist den Algorithmus durch
Kommentare zu erklären, dann fang an den Variablen wie i, j, x, temp, ...
sprechendere Namen zu geben.
Wenn du das kannst, brauchst du keine Kommentare mehr und hast den
Algorithmus verstanden.
Good luck

 

[Ruderer1993]

Ok habe nun mal meine Kommentare geändert und die Namen geändert, so wie ich denke das es passt

public static void selectionSort(int[] unsortedArray) {
        for (int index = 0; index < unsortedArray.length - 1; index++) { //Anzahl der Durchläufe optimieren
            int minIndex = index;  //Index des kleinsten Wertes am Anfang
            for (int indexVonZuVergleichenderZahl = index + 1; indexVonZuVergleichenderZahl < unsortedArray.length; j++) { //Gehe quasi alle Zahlen durch die verglichen werden sollen 
                if (unsortedArray[minIndex] > unsortedArray[indexVonZuVergleichenderZahl]) { //Falls die Zahl von der zu vergleichenden Zahl, kleiner ist als die die wir am Anfang als Minimum festgelegt haben 
                    minIndex = indexVonZuVergleichenderZahl; //Dann ist der Index der zu vergleichenden Zahl der neue Index des minimalsten Wertes
                }
            }
            if (minIndex != index) {  //Falls also der Index der kleinsten Zahl nun getauscht hat
                //Tausche den Wert mit dem kleinsten verfügbaren Wert per Dreieckstausch
                int temp = unsortedArray[index];
                unsortedArray[index] = unsortedArray[minIndex];
                unsortedArray[minIndex] = temp;
            }
        }
    }

Jetzt muss mir nur noch jemand sagen ob es auch stimmt 😉 Danke

 

[Michael...]

Die Kommentare sind m.M. nicht unbedingt Verständnis fördernd und ich habe mir den Code anschauen müssen, um die Kommentare zu verstehen ;-)

Index wird um eins erhöht, wenn die Zahl an dem Index kleiner ist, als die Größe des Arrays erhöhe weiter,sodass er alle Zahlen durchgeht

Hier ist aber der Kommentar definitv falsch:

[JAVA=5]if (x[minIndex] > x[j]) { //Falls das momentane Minimum kleiner ist als die Zahl am Index j[/code]

 

[Ruderer1993]

Die Kommentare sind m.M. nicht unbedingt Verständnis fördernd und ich habe mir den Code anschauen müssen, um die Kommentare zu verstehen ;-)


Hier ist aber der Kommentar definitv falsch:

Es müsste heißen
Falls der Index j kleiner ist als der momentan kleinste Index nämlich minIndex, dann ...

 

[ralfgc]

Neue und sogar optimierte Version:

Klasse

public class SelectionSort {

    public static void sort(int[] array) {
        for (int currentPosition = 0; currentPosition < array.length - 1; currentPosition++) {
            int newPosition = getNewPosition(array, currentPosition);

            if (newPosition != currentPosition) {
                swap(array, newPosition, currentPosition);
            }
        }
    }

    private static int getNewPosition(int[] array, int pos) {
        int biggerValuePosition = pos + 1;

        for (int i = pos; i < array.length; i++) {
            if (array[biggerValuePosition] > array[i]) {
                biggerValuePosition = i;
                break;
            }
        }

        return biggerValuePosition;
    }

    private static void swap(int[] ar, int from, int to) {
        int temp;

        temp = ar[from];
        ar[from] = ar[to];
        ar[to] = temp;
    }
}

Test

public class SelectionSortTest extends junit.framework.TestCase {
    private static int[] array;

    @Override
    public void setUp() throws Exception {
        array = new int[] {9, 6, 8, 5};
    }

    public void testSort() throws Exception {
        SelectionSort.sort(array);

        assertEquals(5, array[0]);
        assertEquals(6, array[1]);
        assertEquals(8, array[2]);
        assertEquals(9, array[3]);
    }
}

 

[Ruderer1993]

vielen Dank, weiß deine Mühe wirklich zu schätzen, doch ich wollte eigentlich wissen ob meine letzte Ausführung nun richtig war und nicht noch einen Code bekommen, wo ich nicht genau weiß ob ich ihn verstehe oder nicht

 

[ralfgc]

Ok,

Du könntest die Antwort aus meinem Code rauslesen aber ok.

erstmal...dein Code ist Denglisch.

> for (int index = 0; index < unsortedArray.length - 1; index++) { //Anzahl der Durchläufe optimieren
Das optimiert nix.

> int minIndex = index; //Index des kleinsten Wertes am Anfang
Das ist nicht "der kleinste Wert am Anfang". Das ist der mögliche Index in dem Array, wo der Wert
womöglich reingehört. Das KÖNNTE die gleiche Position sein.

> for (int indexVonZuVergleichenderZahl = index + 1; indexVonZuVergleichenderZahl < unsortedArray.length; j++) {
"Prüfe die folgenden Werte in dem Array"

> if (unsortedArray[minIndex] > unsortedArray[indexVonZuVergleichenderZahl]) {
"Habe ich eine Position weiter vorn gefunden?"

> if (minIndex != index) {
"Habe ich eine neue Position für den Wert gefunden?"

Hoffe ich habe jetzt nichts vermehrt 🙂
Den Rest und das mit dem Tauschen der Werte im Array kriegst sicher selber hin.

 

[ralfgc]

Meinen Code nicht benutzen, der funktioniert nicht wirklich 🙂 Aber keine Lust den Fehler zu suchen 🙂