H
huhu
Gast
Ich muss eine Methode zur Sortierung dieser Liste schreiben (ohne Java-Bibliotheksfunktionen zu nutzen):
Die Elemente der Liste sind Rechtecke, die der Größe nach sortiert werden sollen (das kleinste soll zuerst kommen).
Die RechteckElementklasse schaut so aus:
Ich verstehe die einzelnen Methoden der Klassen mehr oder weniger, und Arrays kann ich mit Bubblesort oder Selection sort sortieren, aber bei dieser Aufgabe bin ich trotzdem irgendwie überfragt. Kann mir jemand einen Tipp geben wie das geht/ wie ich anfangen soll?
Java:
public class RechteckListe {
// Konstruktoren
public RechteckListe() {
first = null;
}
public RechteckListe(Rechteck r) {
first = new RechteckElement(r);
}
/**
* Testet ob die Liste leer ist
* @return true falls die Liste leer ist
*/
public boolean isEmpty() {
return (first == null);
}
/**
* Fügt ein Rechteck vorne in die Liste ein
*
* @param r Rechteck, welches zum neuen Kopf der Liste werden soll
*/
public void addFirst(Rechteck r) {
first = new RechteckElement(r, first);
}
/**
* Entfernt den Kopf der Liste
*
* @return entferntes Rechteck, welches am Kopf der Liste stand
*/
public Rechteck removeFirst() {
Rechteck result = null;
if (first == null) {
System.out.println("Warnung: removeFirst auf leere Liste angewandt!");
// removeFirst liefert in diesem Fall null zurück.
} else {
// Null-Pointer Exception ist hier ausgeschlossen, da first != null gelten muss.
result = first.getValue();
first = first.getNext();
}
return result;
}
/**
* Wie removeFirst(), ohne jedoch das Rechteck aus der Liste zu enternen
*
* @return Rechteck, welches momentan am Kopf der Liste steht
*/
public Rechteck readFirst() {
Rechteck result = null;
if (first == null) {
System.out.println("Warnung: readFirst auf leere Liste angewandt!");
// readFirst liefert in diesem Fall null zurück.
} else {
// Null-Pointer Exception ist hier ausgeschlossen, da first != null gelten muss.
result = first.getValue();
}
return result;
}
/**
* Hängt eine gegebene Liste von Elementen hinten an
*
* @param l
* Liste, welche hinten angehängt werden soll
*/
public void append(RechteckListe l) {
if (first == null) {
first = l.first;
} else {
RechteckElement next = first;
while (next.getNext() != null) {
next = next.getNext();
}
next.setNext(l.first);
}
}
/**
* Dreht die Reihenfolge der list um.
*/
public void reverse() {
RechteckElement last = null;
RechteckElement current = first;
while (current != null) {
RechteckElement next = current.getNext();
current.setNext(last);
last = current;
current = next;
}
first = last;
}
/**
* Fügt das Rechteck vor das erste größere Rechteck in die Liste ein
*
* @param r Rechteck, welches geordnet eingefügt werden soll.
*/
public void insert(Rechteck r) {
if (first == null || r.isSmaller(first.getValue())) {
this.addFirst(r);
} else {
first.insertAfter(r);
}
}
/**
* Sortiert die Liste der Größe nach, wobei das kleinste Rechteck am Anfang steht.
*/
public void sort() {
// Meine Aufgabe
}
}Die Elemente der Liste sind Rechtecke, die der Größe nach sortiert werden sollen (das kleinste soll zuerst kommen).
Die RechteckElementklasse schaut so aus:
Java:
public class RechteckElement {
private RechteckElement next;
private Rechteck value;
public RechteckElement(Rechteck r) {
value = r;
next = null;
}
public RechteckElement(Rechteck r, RechteckElement n) {
value = r;
next = n;
}
/**
* @return the next
*/
public RechteckElement getNext() {
return next;
}
/**
* @param next the next to set
*/
public void setNext(RechteckElement next) {
this.next = next;
}
/**
* @return the value
*/
public Rechteck getValue() {
return value;
}
/**
* @param value the value to set
*/
public void setValue(Rechteck value) {
this.value = value;
}
public void insertAfter(Rechteck r){
if (next == null || r.isSmaller(next.getValue())) {
next = new RechteckElement(r, next);
} else {
next.insertAfter(r);
}
}
}Ich verstehe die einzelnen Methoden der Klassen mehr oder weniger, und Arrays kann ich mit Bubblesort oder Selection sort sortieren, aber bei dieser Aufgabe bin ich trotzdem irgendwie überfragt. Kann mir jemand einen Tipp geben wie das geht/ wie ich anfangen soll?
