Insertion Sort (mit Comparable interface und compareTo)

anos3

Mitglied
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

Top Contributor
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.
 
G

Gelöschtes Mitglied 65838

Gast
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

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

Gelöschtes Mitglied 65838

Gast
Java:
        // 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
 
G

Gelöschtes Mitglied 65838

Gast
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

Mitglied
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:
Java:
        for(int i=1; i<=f.length; i++) {
            for(int j=i-1; j>0 && (f[j].compareTo(f[j-1]))<0;j--) {
 

Oneixee5

Top Contributor
Dieser Code ist weitestgehend sinnfrei:
Java:
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.
 
G

Gelöschtes Mitglied 65838

Gast
Java:
       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
 
K

kneitzel

Gast
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.
 
K

kneitzel

Gast
Java:
       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
Dir ist aber bewusst, dass es um die Implementierung vom Compareable Interface geht? Und da ist die Signatur vorgegeben mit einer festen Bedeutung ...
 

anos3

Mitglied
Dieser Code ist weitestgehend sinnfrei:
Java:
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.
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]
 
G

Gelöschtes Mitglied 65838

Gast
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
 

Neue Themen


Oben