Moin..
ich bin hier gerade voll bei der SortedList am scheitern ;(( kann mir vielleicht jemand helfen? Ist ziemlich dringend, da wir ja bis heute 0 uhr abgegeben haben muessen ;(
Nodes haben ein paar Zugriffmethoden, wie nextNode() (Referenz auf den naechsten Node) und setPointer() (setzt die Referenz auf den naechsten Node)
Ich habe einen firstNode.. beim Iterieren mache ich
Node currentNode = firstNode;
Dann latsche ich durch die Liste durch und mache die Vergleiche (Comparatoren funktionieren einwandfrei).. sobald ich auf ein currentNode.nextNode().getElement() stosse, welches kleiner ist, als das Einzufuegende Element wird es davor eingefuegt. Wenn er bei nem Node ankommt wo der Pointer auf null zeigt, dann wird der Pointer einfach auf mein neues Element gesetzt (den Node der es enthaelt), was ja beim Start schon direkt der Fall ist.

funktioniert aber alles nicht ;(
ich wuerde mich sehr freuen, wenn es sich mal jemand unter:
http://www.yumdap.net/zettel1.zip
anschauen koennte..

gruss
dakira

bloss kein package verwenden..

zu add:

size ist am anfang 0, also wird die for schleife nie
duchlaufen, es wird nie etwas eingefügt

setPointer doch besser in setNextNode umbenenen?

zu delete(int i):

kein size– vorhanden

zur fehlervermeidung lohnt sich dort der befehl

delete(elementAt(i));

nach der exception



zu delete(Object o):

kein size– vorhanden



zu elementAt(int i):

gleiche exceptionbehandlung wie in delete(int i) würd ich vorschlagen,

if(i>=pos){ return null; }
dürfte für alle sinnvollen parameter null zurückgeben

kein pos++


max() :

oh, bei dir ist firstNode gar nicht der erste knoten,
sondern firstNode.nextNode() ?,
na ob das mal klappt, eigentlich ja nicht im sinne des
erfinders,

edit
wie ich grad seh, steht das im skript doch so, na dann [img]http://images.rapidforum.com/images/i14.gif[/img]

fall leere list abfangen

min() :

wie wärs mit
return elementAt(size-1);

da die while schleife bei nextNode()=null abbricht,
wird die gleiche if-abfrage darin nie wahr..

to be continued..

kann mir vielleicht jemand helfen? Ist ziemlich dringend, da wir ja bis heute 0 uhr abgegeben haben muessen

Das naechste Mal vorher posten! Kannst Du Dir wahrscheinlich auch selbst denken. Naja ansehen werde ich es mir auf jeden Fall.

NP: Spiral Architect

if&#x28;&#x28;&#x28;Person)o1).getGeburtsdatum().compareTo&#x28;&#x28;&#x28;Person)o2).getGeburtsdatum()) < 0){
return 1;
}
if&#x28;&#x28;&#x28;Person)o1).getGeburtsdatum().compareTo&#x28;&#x28;&#x28;Person)o2).getGeburtsdatum()) > 0){
return -1;
}
if&#x28;&#x28;&#x28;Person)o1).getGeburtsdatum().compareTo&#x28;&#x28;&#x28;Person)o2).getGeburtsdatum()) == 0){
return 0;
}

Geht auch einfacher (das gleiche gilt analog fuer den NameComparator):

return ((Person)o1).getGeburtsdatum().compareTo&#x28;&#x28;&#x28;Person)o2).getGeburtsdatum());



Zur SortedList
————–

Prinzipiell lohnt es sich, zwei DummyNodes beim Initialisieren in die Liste zu tun - einen, der ganz am Anfang steht und auf den ersten echten Knoten in der Liste verweist, sowie einen am Ende, auf den der letzte echte Knoten verweist. So sparst Du Dir laestiges Abfragen von Sonderfaellen beim Manipulieren der Liste, weil jedes echte Element IMMER einen Vorgaenger und Nachfolger hat.

Per i=this.size; aus der Schleife auszubrechen ist schon sehr merkwuerdiger Programmierstil… ich habe es in Java bisher nie gebraucht, aber da gibt es doch sicher eine break-Anweisung?
Generell faellt es schwer, sich in den Code einzuarbeiten, der ist ja so gut wie gar nicht kommentiert. Also ich fuerchte ich werde Dir da auf die Schnelle mit dem speziellen Problem leider nicht weiterhelfen koennen…

Bei delete(int i) laesst Du negative Zahlen zu. Dass zu grosse Zahlen eine Exception ausloesen ist gut, aber Du solltest auch eine entsprechende Vorbedingung in den Javadoch Kommentar der Methode setzen. Die Schleifenkonstruktion sieht schon wieder sehr merkwuerdig und auf den ersten Blick undurchschaubar aus.

currentNode=currentNode.nextNode();

Beim Löschen eines Knotens solltest Du den Zeiger des vorhergehenden Knotens verbiegen und nicht den eigentlichen Knoten neu belegen. Du weist hier lediglich einer lokalen Knotenvariable einen neuen Wert zu, das veraendert die Liste natuerlich nicht.
Du musst bei Deiner Implementation ausserdem den Sonderfall beachten, dass man das Element 0 aus der Liste löschen möchte, weil dann der FirstNode oder wie das bei Dir heisst verbogen werden muss.

Was auch auffaellt: der Algorithmus zum Auffinden eines Elementes in der Liste ist bei Dir sehr oft im Code vorhanden, ich wuerde den nur einmal schreiben und dann aufrufen. Ausserdem berücksichtigt er nicht die Eigenschaft der Sortiertheit der Liste (z.b. bei delete(o) und contains(o)).

Bei elementAt hast Du vergessen pos++ zu schreiben.

Oh an Deiner max Methode sehe ich gerade, dass der "first" Node anscheinend ein Dummynode ist - gut! Aber das musst Du kommentieren, mit Javadoc, sonst versteht das doch keiner (ich z.B.).



NP: (passend zum eisigen Wetter) Iced Earth - Angel's Holocaust

so mit den änderungen, die ich unten beschrieben habe, lief unser testlauf fehlerfrei durch,
allerdings muss dieser ja nicht das mass aller dinge sein [img]http://www.sternenvolk.de/symb/22.gif[/img],

@Fred das zu delete ist bei dir falsch, nicht verwirren

falls du das nicht alles selber eintippen willst:

bis auf autoren, evtl. teilweise falsche operationsnamen,
da ich die umbenennen musste für meine hilfsklassen,

(wenn du aus zitiermodus kopierst, bleiben die tabs und leerzeichen erhalten)

import java.util.Comparator;

/**
* Klasse SortedList
* eine einfach verkettete Liste die Neue Einträge in absteigend
* sortierter Reihenfolge aufnimmt
* @version 0.1
*/

public class SortedList {

//
// Variablen
//
private Comparator comp;
private int size=0;
private Node firstNode = new Node(null, null);

//
// Konstruktoren
//
/**
* Konstruktor fuer SortedList
* @param comp ein Comparator-Object
*/
public SortedList(Comparator comp) {
this.comp=comp;
}

//
// Methoden
//
/**
* Sortiertes Einfügen eines neuen Elements
* @param o einzufügendes Element
* @throws Exception
*/
public void add(Object o) throws Exception{
Node newNode = new Node(o, null);
Node currentNode = firstNode;
for(int i=-1; i<this.size; i++){
if(currentNode.nextNode()==null){
currentNode.setPointer(newNode);
this.size++;
i=this.size;
}else{
if(comp.compare(o, currentNode.nextNode().getElement()) == 0){
throw new Exception("Element schon in Liste enthalten");
}else{
if(comp.compare(o, currentNode.nextNode().getElement()) > 0){
newNode.setPointer(currentNode.nextNode());
currentNode.setPointer(newNode);
this.size++;
i=this.size;
}
}
}
currentNode = currentNode.nextNode();
}
}

/**
* Element an Position i löschen
* @param i Position des zu löschenden Elements
* @throws Exception
*/
public void delete(int i) throws Exception{
if(i >= this.size){
throw new Exception("Kann Element "+i+" nicht löschen, da die "+
"Liste nur "+this.size+" Elemente enthält!");
}
int pos=0;
Node currentNode=firstNode;
while(currentNode.nextNode()!=null){
if(pos==i){
currentNode.setPointer(currentNode.nextNode().nextNode());
size–;
return;
}else{
currentNode=currentNode.nextNode();
}
pos++;
}
}

/**
* Entfernen des Elementes o
* @param o Das zu entferndende Object
*/
public void delete(Object o){
Node currentNode=firstNode;
while(currentNode.nextNode()!=null){
if(comp.compare(o,currentNode.nextNode().getElement()) == 0){
currentNode.setPointer(currentNode.nextNode().nextNode());
size–;
}else{
currentNode = currentNode.nextNode();
}
}
}

/**
* ist das Objekt enthalten enthalten?
* @param o Das Objekt, welches in der Liste gesucht werden soll
* @return boolscher wert
*/
public boolean contains(Object o ){
Node currentNode=firstNode;
while(currentNode.nextNode()!=null){
if(comp.compare(o,currentNode.nextNode().getElement()) == 0){
return true;
}else{
currentNode = currentNode.nextNode();
}
}
return false;
}

/**
* Gibt Element an Position i zurück
* @param i Position
* @return das Objekt an Position i
*/
public Object elementAt(int i){
int pos=0;
if(i<pos){
return null;
}
Node currentNode=firstNode;

while(currentNode.nextNode()!=null){
if(pos==i){
return currentNode.nextNode().getElement();
}else{
currentNode=currentNode.nextNode();
}
pos++;
}
return null;
}

/**
* Anzahl der Einträge
* @return Länge der Liste
*/
public int size(){
return this.size;
}

/**
* kleinstes Element der Liste
* @return kleinstes Element der Liste
*/
public Object min(){
return elementAt(size-1);
}

/**
* größtes Element der Liste
* @return größtes Element der Liste
*/
public Object max(){
if (firstNode.nextNode()==null) {
return null;
} else {
return firstNode.nextNode().getElement();
}
}

/**
* gibt die Liste als Text aus
* @return Liste als Text
*/
public String toString(){
Node currentNode = firstNode;
StringBuffer text = new StringBuffer();

while(currentNode.nextNode()!=null){
text.append(currentNode.nextNode().getElement().toString());
text.append("\n");
currentNode = currentNode.nextNode();
}
return text.toString();
}
}

@slater Da kann was nicht stimmen. In unserem Test prüfe ich eigentlich auch die Size nach delete(int i) und delete(Object o). Nur gibts bei Fehlern keine Exceptions sondern man muss sich schon angucken, was da auf der Kommandozeile rauskommt. Mit JUnit wäre das natürlich schöner.

Mist, jetzt hast Du Deinen Kommentar zu size() ja rausgenommen…

eben, gerade aus rücksicht auf dich, hatte ich dann auch bemerkt [img]http://www.sternenvolk.de/symb/28.gif[/img]

nu muss ich aber langsam abschicken ;)

danke

erstellt 04.11.2002 ****23:42*****

Slater, Du hasts ja irgendwie mit diesen Zahlen, wa??? Du machst das mit Absicht, oder?

MoKrates

Eigentlich gehört das nicht so richtig hier her, aber wir hatten anfangs das Problem, das unsere Listenimplementation funktioniert hat und er das ganze auch schön lexikographisch einsortiert hat. Komischerweise war aber nach der SortedList Methode (die wir dementsprechend definiert haben) nix mehr in der Liste drin, folglich hat der Garbage Collector das gefressen [img]http://www.sternenvolk.de/symb/8.gif[/img] Wir haben dann mit Hilfe eines Tutorials so ne Art "Zeiger" definiert und nun klappts. Ich fands insgesamt gar net so einfach.
Aber was habt ihr zu Aufgabe 4C geschrieben???? Das würd mich ma interessieren…. [img]http://www.sternenvolk.de/symb/5.gif[/img]

Wenn man die equals-Methode nicht überschreibt, dann wird einfach die von Comparator verwendet. Die funktioniert auch.
Wenn ich wollte, dass z.B. zwei Personen gleich sind, die nur gleich heißen, dann müsste ich die equals methode überschreiben, aber das will ich ja nicht.

Wenn man die equals-Methode nicht überschreibt, dann wird einfach die von Comparator verwendet.

Soweit korrekt.

Wenn ich wollte, dass z.B. zwei Personen gleich sind, die nur gleich heißen, dann müsste ich die equals methode überschreiben, aber das will ich ja nicht.

Nein, ueberleg doch mal, was die equals Methode eines Objektes vergleicht - Objekte eben des selben Typs! Im Falle Comparator also Comparatoren. Du kannst also zwei Comparatoren miteinander vergleichen. Wo aber wollen wir das? Nirgends! Hat mit Personen vergleichen nix zu tun, das wird ja in der compare Methode des Comparators gemacht.

erstellt 04.11.2002 ****23:42*****

Slater, Du hasts ja irgendwie mit diesen Zahlen, wa???

Immer diese Verschwoerungstheoretiker - obwohl ich zugebe, dass es mich auch fasziniert, juengstes Beispiel ist ja das Moskauer Geiseldram, das am 23. Oktober begann.
Ab hier ist die 23 wirklich nicht verwunderlich, schliesslich muss er es irgendwann vor Mitternacht abgeben, und da laesst er sich halt moeglichst viel Zeit. Und die 42 ist ziemlich wahrscheinlich Zufall (oder auch nicht) [img]http://www.sternenvolk.de/symb/7.gif[/img]

Ich fands insgesamt gar net so einfach.

Es war insofern nicht so schwer, als es schon mal in P2 ne aehnliche Aufgabe gab (nur eben nicht sortiert die Liste).

erstellt 04.11.2002 ****23:42*****

Slater, Du hasts ja irgendwie mit diesen Zahlen, wa??? Du machst das mit Absicht, oder?

MoKrates

ich sein unschuldig [img]http://www.sternenvolk.de/symb/12.gif[/img]
ausserdem entscheide ich mich zwischen smiley { 22] und [ 23] fast immer für [ 22] [img]http://www.sternenvolk.de/symb/22.gif[/img]