Es ist eine Liste von Java. Das ganze ist nur kompliziert, weil man dort ja nicht einfach an jede beliebige Stelle wie bei einem Array greifen kann, sondern immer nur den Current hat. Die Liste soll dann mit Hilfe von Bubblesort sortiert werden.Wo ist denn das genaue Problem? Woran scheiterst Du?
Die Frage ist erst einmal, was Du für eine Liste hast. Wenn es eine List von Java meint, dann hast Du ähnliche Zugriffsmöglichkeiten wie bei einem Array über die set / get Methoden.
Wenn Du eine eigene Liste sortieren musst, dann wäre die Frage, was Du da an Zugriffsmöglichkeiten hast. Und dann kannst Du die Sortieralgorithmen durchgehen, die Du anwenden kannst. Und bei einer einfach verlinkten Liste ist tatsächlich ein Sortierverfahren wie Bubblesort eine nicht schlechte Idee.
Also wenn es eine Liste von Java ist, also java.util.List implementiert wurde, dann hast Du auch den Zugriff über den Index.Es ist eine Liste von Java. Das ganze ist nur kompliziert, weil man dort ja nicht einfach an jede beliebige Stelle wie bei einem Array greifen kann, sondern immer nur den Current hat. Die Liste soll dann mit Hilfe von Bubblesort sortiert werden.
Angenommen, du musst die Liste verwenden, die vom Bundesministerium vorgeschrieben ist. In dieser Liste werden hauptsächlich die MethodenEs ist eine Liste von Java. Das ganze ist nur kompliziert, weil man dort ja nicht einfach an jede beliebige Stelle wie bei einem Array greifen kann, sondern immer nur den Current hat. Die Liste soll dann mit Hilfe von Bubblesort sortiert werden.
toFirst()
hasAccess()
getContent()
bubbleSort(Array A)
for (n = A.size; n > 1; n = n - 1) { // äußere Schleife
for (i = 0; i < n - 1; i = i + 1) { // innere Schleife
if (A[i] > A[i + 1]) {
A.swap(i, i + 1)
}
}
}
List<Integer> sortedList = new List<Integer>();
int pointer;
listToSort.toFirst();
while (listToSort.hasAccess()) {
pointer = listToSort.getContent();
sortedList.toFirst();
while (sortedList.hasAccess()) {
if (pointer < sortedList.getContent()) {
sortedList.insert(pointer);
break;
}
sortedList.next();
}
if (!sortedList.hasAccess()) {
sortedList.append(pointer);
}
listToSort.next();
}
Das ganze müsste in der unsortierten Liste ohne eine neue Liste funktionieren.Angenommen, du musst die Liste verwenden, die vom Bundesministerium vorgeschrieben ist. In dieser Liste werden hauptsächlich die Methoden,Java:toFirst()
undJava:hasAccess()
verwendet. Wenn wir uns nun den Pseudocode für Bubble Sort anschauen:Java:getContent()
(kommt von Wikipedia: https://de.wikipedia.org/wiki/Bubblesort)Code:bubbleSort(Array A) for (n = A.size; n > 1; n = n - 1) { // äußere Schleife for (i = 0; i < n - 1; i = i + 1) { // innere Schleife if (A[i] > A[i + 1]) { A.swap(i, i + 1) } } }
kann man ihn mit den genannten Methoden umsetzen. Das sieht dann grob so aus:
Java:List<Integer> sortedList = new List<Integer>(); int pointer; listToSort.toFirst(); while (listToSort.hasAccess()) { pointer = listToSort.getContent(); sortedList.toFirst(); while (sortedList.hasAccess()) { if (pointer < sortedList.getContent()) { sortedList.insert(pointer); break; } sortedList.next(); } if (!sortedList.hasAccess()) { sortedList.append(pointer); } listToSort.next(); }
Nun ist die Liste sortiert und in der neuen Liste gespeichert.
Ich probiere die ganze Zeit verschiedene Möglichkeiten an Code, komme aber gar nicht weiter.Sorry, aber was hast Du Dir denn bisher an weiteren Gedanken gemacht? Du hast einige Antworten bekommen, die Dir weiter helfen sollten. Wenn nicht wäre wichtig, dass Du schreibst, wo es hakt.
Ziel sollte sein, dass Du lernst, so Aufgaben selbst zu lösen…
Ich habe schon einen Code, der einen Array sortiert. Das war auch nicht so schwer. Ich tue mich jedoch schwer dabei, mit Currents in Listen zu arbeiten, weil ich dort ja nicht wie bei einem Array einfach in einer For-Schleife mit der aktuellen Zahl aus der For-Schleife auf eine beliebige Stelle im Array zugreifen kann. Den Current kann ich ja immer nur um eins nach hinten schieben.Wenn Du uns Details nennst, dann hast Du eine Chance, dass wir Dir weiter helfen. Ohne diese wird es aber sehr schwer.
Und hast Du Dir denn schon ein generelles Vorgehen überlegt? Das ist IMMER der erste Schritt. Ohne ein Verständnis des Problems und der Lösung wäre es ein absoluter Zufall, einen funktionierenden Code zu erstellen.
Ist die Liste, die "HerrInfo" oben angemerkt hat. Danke erstmal. Ich schaue, ob ich damit etwas anfangen kann.Also kommen wir erst einmal zu einer früheren Frage zurück: Was genau für eine Liste hast Du? Es ist nach Deinen aktuellen Aussagen nicht die java.util.List von Java sondern ganz offensichtlich eine einfache linked list.
Da wäre dann die Frage: Was für Zugriffe hast Du auf die Liste? Oder hast Du alle Zugriffe und kannst komplett auf alles zugreifen weil die Methode Bestandteil der List wird?
Aber fangen wir einfach an und überlegen diverse Szenarien:
- Leere Liste -> Kannst Du den Fall abhandeln?
- Liste mit einem Element -> Kannst Du den Fall abhandeln?
- Liste mit 2 Elementen -> Kannst Du den Fall abhandeln?
- Liste mit 3 Elementen -> Wie sieht es da jetzt aus? Kannst Du evtl. das, was Du mit 2 Elementen gemacht hast, hier anwenden?
Das wäre eine Schritt für Schritt Herangehensweise. Und stell es Dir bildlich vor! Ich habe versucht, Dir da ein Szenario aufzumalen mit Streichholzschachteln und Wäscheklammern.
Aber Du kannst es Dir auch wie ein Zug vorstellen. Du hast eine Lok mit Anhängern. Lok und Anhänger sind alle Verbunden, aber die Tür zwischen Lok und Anhänger oder zwischen zwei Anhängern lässt sich nur von der Lok Seite aus öffnen.
Du stehst am Bahnsteig und kannst Leute in den Zug schicken. Du hast aber nur eine begrenzte Anzahl an Leuten und Du musst halt sagen, wie viele Du brauchst. Eine Person gibt es und das ist der Lokführer.
Vom Bahnsteig aus kannst Du in den Zug, aber die Tür muss von außen geöffnet werden.
Damit Du etwas mit dem Inhalt des Anhängers machen kannst, muss eine Person in dem Anhänger sein.
Nun kannst Du damit Dinge machen. Du willst also z.B. die Anzahl der Anhänger zählen. Dazu schickst Du eine Person in den Zug. Und die Person geht dann von der Lok (dem Kopf der Liste) von Anhänger zu Anhänger und immer wenn er in einen Anhänger geht, zählt er einen Zähler hoch.
==> Das ist dann vermutlich ein Ablauf, den Du kennst um die Anzahl der Elemente zu zählen.
Und nun kannst Du schauen, ob Du mit so einem Szenario etwas machen kannst, um dann einen Lösungsweg zu finden. Den Lösungsweg kann man dann einfach in Code umsetzen. Personen sind dann Variablen, die Lok ist der Kopf der Liste (So es den gibt, ggf. ist da auch einfach ein erster Anhänger) und die Anhänger sind die Knoten der Liste.
Die kenne ich nicht. Kannst Du bitte die genauen Details teilen?Ist die Liste, die "HerrInfo" oben angemerkt hat. Danke erstmal. Ich schaue, ob ich damit etwas anfangen kann.
Zeige doch mal was von den Code was du bis jetzt hast.
Da können wir sicherlich sehen was das für eine Liste ist.
public List<Integer> bubbleSort(List<Integer> l) {
int temp1, temp2;
boolean changed = false;
do {
l.toFirst();
temp1 = l.getContent();
l.next();
while(temp1 > l.getContent() && l.hasAccess()) {
temp2 = l.getContent();
l.remove();
l.insert(temp2);
l.insert(temp1);
changed = true;
}
} while(l.hasAccess() && changed == true)
return l;
}
Der Code aus dem Link hier wird mir aber leider nicht wirklich helfen, weil hier das Tauschen ja nur einmal durchgeführt werden kann, weil danach nicht mehr auf die nächste Zahl in der Liste gewechselt wird.Schaue dir mal den Code von meinen ersten Post link 2 an.
Da wird eine Liste übergeben und eine sortierte Liste in der Methode zurückgegeben.
Die sortiertere ist dann nicht direkt die gleiche wie die übergebene Liste .
Es wird in der Methode eine Neue Liste erstellt und in ihr werden die Elemente in sortierter Reihenfolge eingefügt. Und die wird zurückgegeben.
Das macht auch HerrInfo
code aus dem link https://bloggingwelt.de/sortieralgo...nsertion-sort-selection-sort-und-bubble-sort/
Java:public List<Integer> bubbleSort(List<Integer> l) { int temp1, temp2; boolean changed = false; do { l.toFirst(); temp1 = l.getContent(); l.next(); while(temp1 > l.getContent() && l.hasAccess()) { temp2 = l.getContent(); l.remove(); l.insert(temp2); l.insert(temp1); changed = true; } } while(l.hasAccess() && changed == true) return l; }
void sortList(List toSort) {
toSort.toFirst();
while (true) {
findWrongValue(toSort);
if (!toSort.hasAccess) {
// No more wrong values: List is sorted
return;
}
int nextWrongValue = toSort.getContent();
toSort.remove();
insertWrongValue(toSort, nextWrongValue);
}
}
void findWrongValue(List toSort) {
int currentValue = toSort.getContent();
toSort.next();
while (toSort.hasAccess() && currentValue <= toSort.getContent()) {
currentValue = toSort.getContent();
toSort.next();
}
}
void insertWrongValue(List toSort, int insertValue) {
toSort.toFirst();
while (toSort.hasAccess && insertValue > toSort.getContent()) {
toSort.next();
}
toSort.insert(insertValue);
}