Einfach verkette liste?

... komplette Frage anzeigen

2 Antworten

Bitte formatiere deinen Code als Code, das ist leichter lesbar.

Schreib hier eine Antwort oder einen Kommentar oder stell die Frage noch einmal.

Ich hab mal versucht, den Code zu formatieren, fehlende } zu ergänzen und ein paar Rechtschreibfehler zu korrigieren (z. B. auch weil Java case sensitive ist) - alle hab ich bestimmt nicht gefunden:

public class Node {

Int value;
node next;

node(int value , node next){
this.value=value;
this.next=next;
}
} // ich gehe mal davon aus, dass jos(e)phus keine Subklasse von node ist

public class Josephus {
public static int [] josephusOrder(int n, int m){
int[] A= new int[n];
int c=0;

// ring-liste erzeugen ab hier verstehe ich nicht

Node last= new Node(n,null); // also der letzte knoten ohne ein node next
// anscheinend wird die Liste rückwärts aufgebaut,
// indem jeweils ein Knoten vor den jeweils ersten davorgesetzt wird

last.next= last; // keine shnung was es macht und wozu
// an dieser Stelle haben wir einen "Kreis" mit einem einzigen Element,
// das dann natürlich sein eigener Nachfolger sein muss
// last = new node(n, last) geht nicht, weil last zur Zeit seiner Erzeugung noch nicht existiert

Node tmp = last; // ebenfalls keine ahnung wieso und wozu
// tmp ist der Knoten, der als nächster eingefügt wird
// bzw. der als letzter eingefügt worden ist
// das ist am Anfang der einzige vorhandene Knoten, also last

For(int i=n-1; i>=1; i--){ // i läuft die übrigen zu vergebenden Werte rückwärts durch, dann haben wir die Werte 1, ..., n
tmp = new Node (i, tmp);
// wenn der Konstruktor aufgerufen wird,
// ist tmp noch der letzte eingefügte Knoten,
// der nächste Knoten wird vor diesen Knoten eingefügt
// vielleicht sollte man 2 Variablen hierfür nehmen, das wäre übersichtlicher
// Der neu erzeugte Knoten, der den bisher letzten als Nachfolger hat,
// ist der Vorgänger des davor eingefügten
last.next= tmp;
// der neue Knoten wird in den Kreis eingebunden,
// der letzte Knoten bzw. Startknoten zeigt jetzt auf den neu eingefügten
}; // wir müssten hier noch im Aufbau des Kreises sein
// jetzt haben wir n Knoten erzeugt, die in der Reihenfolge 1, 2, ..., n, 1, ... durchlaufen werden

// Auszählen
While (last.next != last){ // Abbruchbedingung: der Kreis enthält wieder nur ein einziges Element,
// das ist genau dann der Fall, wenn dieses Element auf sich selbst verweist
For (int i= 1 ; i<=m; i++) last= last.next; // hab hier aus "i<m" "i<=m" gemacht, damit hier auch wirklich m-mal weitergezählt wird
// m-mal von einem Knoten zum nächsten im Kreis gehen
// statt "last" wäre "current" ein besserer Name
A[c++]= last.next.value; // der Wert des Knotens, auf den wir jetzt zeigen, wird der Liste hinzugefügt
Last.next= last.next.next;
};
// Am Ende der Schleife haben wir noch ein Element im Kreis,
// dieses dürfen wir nicht einzutragen vergessen
// das geschieht mit derselben Codezeile wie in der Schleife
A[c++] = last.next.value;
A[c] = last.value; // Diese Zeile müsste zu einem Laufzeitfehler führen, da jetzt c = n ist und damit außerhalb der gültigen Indizes für A liegt
Return A;
} // die Funktion josephusOrder muss ja irgendwo zuende sein
}

so

Antwort bewerten Vielen Dank für Deine Bewertung

Ergopgle dir dpch erstmal was ne Liste bzw genauer ne einfach verkettete Liste ist, wenn du das nicht weisst. Wenn du das nicht weisst kannst du den Code nämlich nicht verstehen.

Ansonsten kann ich wenn ich am PC bin mal bissl mehr dazu schreiben - aber das meiste ist wsl eh selbsterjlärend.

Antwort bewerten Vielen Dank für Deine Bewertung

Was möchtest Du wissen?