# Insertion Sort (mit Comparable interface und compareTo)



## anos3 (4. Mai 2021)

Die Einträge einer Datenbank sollen mit dem Insertion Sort Verfahren nach Datum (aufsteigend) sortiert werden, im Moment werden scheinbar nur die ersten beiden Einträge verglichen und entsprechend sortiert, also irgendwi bei den Schleifendurchläufen liegt wahrscheinlich der Fehler, stehe nur gerade total auf dem Schlauch:

[CODE lang="java" title="MySort - Insertion Sort Verfahren"]public class MySort {

    public static void mySort(Comparable[] f) {
        // Insertion Sort
        for(int i=1; i<f.length; i++) {
            for(int j=1; j>0 && (f[j].compareTo(f[j-1]))<0;j--) {
                Comparable zwischenspeicher = f[j];
                f[j]=f[j-1];
                f[j-1]=zwischenspeicher;
            }
        }
    }

}
[/CODE]
[CODE lang="java" title="Interface"]public interface Comparable {

    public int compareTo(Comparable other);
}
[/CODE]
[CODE lang="java" title="comparteTo Methode aus der Klasse Lied:"]public class Lied  implements Comparable {


    // Rest der Klasse ausgeklammert


        public int compareTo(Comparable other) {
        int value;
        // other ist vom Typ Lied
        if(other instanceof Lied) {
            // vorderes ist aelter
            if(this.erscheinungsdatum.compareTo(((Lied) other).getErscheinungsdatum()) > 0) {
                value = 1;
            }
            // vorderes ist neuer
            else if(this.erscheinungsdatum.compareTo(((Lied) other).getErscheinungsdatum()) < 0) {
                value = -1;
            // beide gleich alt
            } else {
                value = 0;
            }
        }
        // kein Objekt des Typs Lied:
        else {
            value = 0;
        }
        return value;
    }

}[/CODE]


----------



## Oneixee5 (4. Mai 2021)

Einträge aus einer Datenbank in Java zu sortieren macht überhaupt gar keinen Sinn. Die Datenbank kann das von hause aus durchführen und viel schneller und einfacher als mit Java-Mitteln.


----------



## anos3 (4. Mai 2021)

Oneixee5 hat gesagt.:


> Einträge aus einer Datenbank in Java zu sortieren macht überhaupt gar keinen Sinn. Die Datenbank kann das von hause aus durchführen und viel schneller und einfacher als mit Java-Mitteln.


Das ist nun mal leider meine Hausaufgabe, ob es sinnvoll ist oder nicht ist also unerheblich


----------



## Gelöschtes Mitglied 65838 (4. Mai 2021)

> for(int i=1; i<f.length; i++) {
> for(int j=1; j>0 && (f[j].compareTo(f[j-1]))<0;j--)


hier liegt der fehler du vergleichst immer die stelle 0 und 1 und das bei jedem "i"ten durchlauf soweit ich es beurteilen weil die 2te for schleife keinerlei einfluss von der ersten hat ...du führst einfach nur i mal das gleiche aus für die gleiche stelle also werden dadurch immer der gleiche wert verglichen der natürlich beim ersten mal ausbessern dann stimmt 
 aber ja...die datenbank kann das schneller und fehlerfreier wie oneixxe es beschrieben hat


----------



## Oneixee5 (4. Mai 2021)

Wenn du ein Array deiner Objektinstanzen hast, welche Comparable implementieren, dann sortiert man das wie folgt: `Arrays.sort(meinArray);`


----------



## Gelöschtes Mitglied 65838 (4. Mai 2021)

```
// other ist vom Typ Lied
        if(other instanceof Lied lied) {

.....usw....
            // vorderes ist aelter
            if(this.erscheinungsdatum.compareTo(lied.getErscheinungsdatum()) > 0) {
                value = 1;


..usw..
            }
```
ist schicker ohne Casten das gibts erst ab java 15 als "preview" und ab java 16 ist es fest drin ist sehr schön und macht den code verständlicher


----------



## Gelöschtes Mitglied 65838 (4. Mai 2021)

Oneixee5 hat gesagt.:


> Wenn du ein Array deiner Objektinstanzen hast, welche Comparable implementieren, dann sortiert man das wie folgt: `Arrays.sort(meinArray);`


es geht sehr wahrscheinlich darum um das verständnis wie man einen sortier algorithmus erzeugt und weniger darum was es schon gibt gedenke ich mal sooo


----------



## anos3 (4. Mai 2021)

Joreyk hat gesagt.:


> hier liegt der fehler du vergleichst immer die stelle 0 und 1 und das bei jedem "i"ten durchlauf soweit ich es beurteilen weil die 2te for schleife keinerlei einfluss von der ersten hat ...du führst einfach nur i mal das gleiche aus für die gleiche stelle also werden dadurch immer der gleiche wert verglichen der natürlich beim ersten mal ausbessern dann stimmt
> aber ja...die datenbank kann das schneller und fehlerfreier wie oneixxe es beschrieben hat


ach ja, das waren ja wirklich nur ein paar Zeichen, die ich noch ergänzen musste, sehr gut 😍

so funktioniert es:

```
for(int i=1; i<=f.length; i++) {
            for(int j=i-1; j>0 && (f[j].compareTo(f[j-1]))<0;j--) {
```


----------



## anos3 (4. Mai 2021)

Joreyk hat gesagt.:


> es geht sehr wahrscheinlich darum um das verständnis wie man einen sortier algorithmus erzeugt und weniger darum was es schon gibt gedenke ich mal sooo


genau!


----------



## Oneixee5 (4. Mai 2021)

Dieser Code ist weitestgehend sinnfrei:

```
if(this.erscheinungsdatum.compareTo(((Lied) other).getErscheinungsdatum()) > 0) {
                value = 1;
            }
            // vorderes ist neuer
            else if(this.erscheinungsdatum.compareTo(((Lied) other).getErscheinungsdatum()) < 0) {
                value = -1;
            // beide gleich alt
            } else {
                value = 0;
            }
```

einfach: `return this.erscheinungsdatum.compareTo(((Lied) other).getErscheinungsdatum());`
compareTo gibt dir ja schon ein int als Rückgabe, es ist also unnötig noch mal ein neues int zu erzeugen.


----------



## Gelöschtes Mitglied 65838 (4. Mai 2021)

```
public boolean compareTo(Comparable other) {
        // other ist vom Typ Lied
        if(other instanceof Lied) {
            // vorderes ist aelter
            if(// Bedingung dass getauscht werden MUSS ) {
                return true;
            }
        }
        // kein Objekt des Typs Lied:
        else {
            // throw Exception
        }
         return false;
    }
```

so hab jetzt mal harakiri gemacht mit deinem code versucht es mal mit diesen Satz zu verstehen
" Es gibt 3 zustände ,
1. es muss getauscht werden
2. es muss nicht getauscht werden
3. es ist schwachsinn übergeben worden -> fehler meldung zurück"

dann hast du noch das schleifen problem wie oben beschrieben


----------



## kneitzel (4. Mai 2021)

Also für jemand, der gerade versucht, Sortier-Algorithmen zu verstehen und zu implementieren haut Ihr ihm ganz schön was um die Ohren ... 

Pattern Matching with instance of ist ab Java 14 (JEP 305) verfügbar. In 15 war es immer noch Preview (JEP 375) und wie gesagt: ab 16 ist es final (JEP 394).

Bezüglich dem Insertion Sort würde ich Dir empfehlen, noch einmal die Funktionsweise auf https://de.wikipedia.org/wiki/Insertionsort anzusehen. Generell ist der Fehler in der inneren Schleife zu finden - da müsstest Du Dir die Grenzen noch einmal ansehen.


----------



## kneitzel (4. Mai 2021)

Joreyk hat gesagt.:


> ```
> public boolean compareTo(Comparable other) {
> // other ist vom Typ Lied
> if(other instanceof Lied) {
> ...


Dir ist aber bewusst, dass es um die Implementierung vom Compareable Interface geht? Und da ist die Signatur vorgegeben mit einer festen Bedeutung ...


----------



## anos3 (4. Mai 2021)

Oneixee5 hat gesagt.:


> Dieser Code ist weitestgehend sinnfrei:
> 
> ```
> if(this.erscheinungsdatum.compareTo(((Lied) other).getErscheinungsdatum()) > 0) {
> ...


oh ja da hast du recht, vielen lieben Dank! Hatte beim Algortihmus erst was anderes und dann vergessen, das wieder zu verändern!
sieht jetzt so aus:
[CODE lang="java" highlight="5"]    public int compareTo(Comparable other) {
        int value;
        // other ist vom Typ Lied
        if(other instanceof Lied) {
            value = this.erscheinungsdatum.compareTo(((Lied) other).getErscheinungsdatum());
        }
        // kein Objekt des Typs Lied:
        else {
            value = 0;
        }
        return value;
    }[/CODE]


----------



## Gelöschtes Mitglied 65838 (4. Mai 2021)

anos3 hat gesagt.:


> oh ja da hast du recht, vielen lieben Dank! Hatte beim Algortihmus erst was anderes und dann vergessen, das wieder zu verändern!


hö was ist jetzt sinnfrei ich bin verwirrt was möchtest du denn jetzt gerade machen ?
eig das was ich umgemodelt hab sollte funktionieren


das mit dem Pattern matching von java 14 15 16 war als HINWEIS gedacht... um schickeren code zu fabrizieren deines war auch RICHTIG mit casten
es war als tipp gedacht..hätte ich das damals gewusst hätte ich das immer benutzt anstatt casten weil mich casten sehr verwirrt und alles was verwirrt ist schlecht im code


das schleifen problem ist ja weiter noch da was ich dir geschrieben hatte


----------

