• Wir präsentieren Dir heute ein Stellenangebot für einen Java Entwickler - m/w/d in Augsburg, München, Stuttgart oder Bamberg. Hier geht es zur Jobanzeige

Insertion Sort (mit Comparable interface und compareTo)

A

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:

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;
            }
        }
    }

}
Interface:
public interface Comparable {

    public int compareTo(Comparable other);
}
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;
    }
    
}
 
Oneixee5

Oneixee5

Bekanntes Mitglied
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.
 
A

anos3

Mitglied
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 :)
 
J

Joreyk

Bekanntes Mitglied
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

Oneixee5

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

Joreyk

Bekanntes Mitglied
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
 
J

Joreyk

Bekanntes Mitglied
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
 
A

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

Oneixee5

Bekanntes 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.
 
J

Joreyk

Bekanntes Mitglied
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
 
kneitzel

kneitzel

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

kneitzel

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

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:
Java:
    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;
    }
 
J

Joreyk

Bekanntes Mitglied
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
 
Anzeige

Neue Themen


Oben