Methoden Einfach verkette Liste - int Werte aufsteigend sortieren

[canton]

Hey Forum,
habe hier bereits die Suche bemüht bin aber aus den bestehenden Threads leider nicht schlauer geworden.

Habe eine Aufgabe vor mir liegen bei der eine einfach verkette Liste mit int Werten aufsteigend sortiert werden soll. Also falls aktueller Wert des Knoten größer als der des Folgeknotens --> Werte tauschen.

Der Einfachheit halber wird bei der Liste nicht zwischen Listenelementen und der Liste unterschieden. Also alles in einer Klasse.

Die Klasse dazu:

public class Node {
    int wert;
    Node next;
 
    public Node(int value, Node next) {
        this.wert = value;
        this.next = next;
    }
 
    public static void bubbleSort(Node m) {
        int count =0;
        while(m != null) {
            count++;
            m = m.next;
        }
     
        int hilf;
     
        for(int i=0; i<count; i++) {         
            if(m.wert > m.next.wert) {             
                hilf = m.wert;
                m.wert = m.next.wert;
                m.next.wert = hilf;
                m = m.next;
            }
            else m=m.next;         
        }
    }

Meine Überlegungen dazu waren:
- Zählen wie lang die Liste und anschließend mit einer for Schleife die Liste
die Anzahl durchzulaufen und dabei per Ringtausch die Werte zu sortieren...

Das Programm wirft nun leider eine Nullpointer Exception, was ja bedeutet das meine if Abfrage ins Niemandsland (null) führt...


Falls jemand einen Tipp hat wäre ich sehr dankbar!


PS: Mein Text war deutlich umfangreicher aber als ich posten wollte war ich schon ausgeloggt und es kam eine Fehlermeldung, habe dann auf "zurück" im Browser geklickt wodurch ich zwar wieder hierhin gelangt bin aber der halbe Text ist weg :/

 

[kneitzel]

Ich habe das jetzt nicht im Detail durchdacht, aber mein Verdacht würde gefühlsmäßig auf die Länge Deiner Schleife fallen. Du ermittelst die Anzahl der Elemente und dann gehst Du die Elemente durch in der Schleife. Aber da Du ja auch immer auf m und m.next zugreifst, wirst Du hier auf ein Fehler laufen (Du hast sozusagen das aktuelle Element und den Nachfolger im Zugriff. Beim letzten Element gibt es aber keinen Nachfolger mehr!)

Und dann sehe ich nur eine Schleife. Aber mit der Schleife bringst Du ja nur das größte Element nach hinten. Daher brauchst Du eine zweite Schleife. Die zu betrachtenden Elemente können aber jedes Mal um eins reduziert werden, da ja fest steht, dass das größte Element vom Rest immer am Ende gelandet ist.

Und noch eine Optimierung. In Deinem if/else hast du als letztes den gleichen Befehl. Also

if (bedingung) {
  // Something in if
  a;
} else {
  // Something in else
  a;
}

Hier ist dann der Befehl a; "ausklammer bar". Also Du kannst den Befehl hinter die if Anweisung bringen. Und da es der Einzige Befehl im else Zweig ist, entfällt dieser.