Werte eines Objekts übernehmen

[Mujahiddin]

Ich programmiere Binärbäume. Ich wollte nun in der GUI eine Liste von Bäumen erstellen und jedes Mal, wenn der 'Benutzer' etwas am Baum verändert, werden die Änderungen vorgenommen und der Baum wird der Liste hinzugefügt. Das will ich zumindest abzielen.
Ich arbeite hier mit einer ArrayList und den veränderten Baum in die Liste zu übernehmen, sieht folgendermaßen aus:

Baum newBaum = new Baum()
newBaum = binbaum;      // binbaum = der Baum, den der Benutzer sieht
binaerbaeume.add(newBaum);

Das Problem liegt darin, dass jedes Mal, wenn am binbaum, also am 'sichtbaren' Baum etwas geändert wird, werden die Änderungen in alle Unterbäume der ArrayList übernommen, und mein Ziel, dadurch ein 'Rückgängig machen (STRG+Z)' zu entwickeln, scheitert.
Ich könnte natürlich eine Methode einbauen, mit der ich alle Werte des binbaums ermittle und einen ganz neuen Baum erzeuge, aber wäre das nicht zu kompliziert?

Habt ihr irgendwelche besseren Vorschläge? Würde mich freuen!
Mit freundlichen Grüßen

Mujahiddin

 

[faetzminator]

[c]Baum[/c] muss Cloneable (Java Platform SE 6) bzw. deren Methode [c]clone()[/c] sinnvoll implementieren. Dann hast du folgenden Einzeiler:

binaerbaeume.add(binbaum.clone());

 

[punkt21]

du weißt mit newBaum = binbaum; jedes mal dem neuen baum binbaum zu. jetzt ist es egal mit welcher referenz du was änderst, denn alle zeigen auf binbaum. und deswegen siehst du auch bei jedem baum die änderungen und nciht nur beim neustens

 

[Tomate_Salat]

Baum newBaum = new Baum()
newBaum = binbaum;      // binbaum = der Baum, den der Benutzer sieht
binaerbaeume.add(newBaum);

Ich sehe das Problem darin: Du übergibst hier keine Objekte, sondern Instanzen. Wenn ich das richtig sehe, hast du in deinem Binaerbeaume viele Objekte die auf EINE instanz verweisen.

ungetestet
versuchs mal mit

newBaum = binbaum.clone();

mfg

Tomate_Salat

Edit Ein Clone-Beispiel:

class MyClass   
    implements Cloneable
{
    private String me;
    
    public MyClass(String str)
    {
        setMe(str);
    }

    public void setMe(String me) {
        this.me = me;
    }

    public String getMe() {
        return me;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException 
    {
        return super.clone();
    }
}

 

[0x7F800000]

Baum newBaum = new Baum()
newBaum = binbaum;      // binbaum = der Baum, den der Benutzer sieht
binaerbaeume.add(newBaum);

Doppelter Unsinn. Kannst genausogut gleich

Baum newBaum = binbaum;
binaerbaeume.add(newBaum);

bzw.

binaerbaeume.add(binBaum);

hinschreiben, bzw. diese ganze ArrayList komplett wegschmeißen, weil's sinnlos ist, dieselbe Referenz zig mal abzuspeichern.

Und mein Ziel, dadurch ein 'Rückgängig machen (STRG+Z)' zu entwickeln, scheitert.

Mit immutablen Bäumen wäre es am einfachsten: da wird nämlich wirklich jedes mal ein _neuer_ immutabler Baum erzeugt, da macht es schon mehr sinn, jeden einzelnen Abzuspeichern. Zur Implementierung siehe Introduction to algorithms - Google Bücher, das Bild auf der Seite 295 sagt imho alles...

Ich könnte natürlich eine Methode einbauen, mit der ich alle Werte des binbaums ermittle und einen ganz neuen Baum erzeuge, aber wäre das nicht zu kompliziert?

naja, das wäre mit Abstand die einfachste Lösung: einfach alles Klonen. Allerdings wird das enorm viel speicher Fressen, und ist nicht so interessant zu implementieren, auf gut deutsch: es ist langweilig und sinnlos, und da lernt man nix bei^^

Habt ihr irgendwelche besseren Vorschläge?

Wenn du jeder Operation eine inverse Operation zuordnen kannst (add(5) -> remove(5)), dann reicht es ja auch, nur die Operationen in einer Liste abzuspeichern, und bei ctrl+z bzw ctrl+y einfach nur die jeweilige Operation zu wiederholen bzw. rückgängig zu machen, wäre Speichertechnisch am sparsamsten, aber im Unterschied zu den immutablen Bäumen würde der Zugriff auf Vorgängerversionen in O(k) statt O(1) gehen.

Zusammenfassend: bei n elementen, k Operationen, c Kosten für add/delete/etc

clone:
O(n*k) speicherverbrauch,
O(n+c) laufzeit zur erzeugung des nächsten Zustandes
O(1) zugriff auf vorgängerversionen

immutable:
O(n+k*ln(n)) erwarteter speicherverbrauch
O(ln(n)) laufzeit zur erzeugung des nächsten Zustandes
O(1) zugriff auf Vorgängerversionen

chronik abspeichern:
O(n+k) speicherverbrauch
O(c) zur erzeugung des nächsten Zustandes
O(k*c) zugriff auf Vorgängerversionen

so in der Art... da muss man halt selber wissen, was man will...

 

[Mujahiddin]

Hilft irgendwie nichts.
Der erste binbaum (der leere, der auch beim Ausführen des Programms direkt gespeichert wird), bleibt bei weiteren Veränderungen noch erfolgreich leer.
Der zweite binbaum dann, wenn ich einen Eintrag einfüge, klappt auch. Ab der dritten Veränderung werden alle binbaeume außer der erste leere binbaum mitverändert... Da soll doch mal wer durchblicken...
Ich bin überfragt...
Weiß wer weiter?

Liebe Grüße.

E: sry, hab nur den zweiten Beitrag gelesen als ich das hier schrieb

@ Ox7...
seite 295 is nich dabei aber ich überleg mir das dann mal später noch...

 

[Landei]

Mit immutablen Bäumen wäre es am einfachsten: da wird nämlich wirklich jedes mal ein _neuer_ immutabler Baum erzeugt, da macht es schon mehr sinn, jeden einzelnen Abzuspeichern. Zur Implementierung siehe [url=http://books.google.com/books?id=NLngYyWFl_YC&dq=cormen+rivest+algorithms&printsec=frontcover&source=bn&hl=de&ei=NN2ES_T5HJqW_Qau_LTHAg&sa=X&oi=book_result&ct=result&resnum=4&ved=0CCAQ6AEwAw#v=onepage&q=&f=false]Introduction to algorithms - Google Bücher[/url], das Bild auf der Seite 295 sagt imho alles...
[/QUOTE]

Würde ich auch vorschlagen.

 

[Mujahiddin]

mit final, super.clone() und beides zusammen probiert, das ist ihm aber egal.
Bei Ausführen des Programms = leerer Baum wird erzeugt.
Bei binbaum.add(new Knoten(blabla)); übernehmen alle Bäume der ArrayList (mit Ausnahme des ersten Baums) die Felder des veränderten Binärbaums.

Heißt:
Ausführen: List<Baum(leer)>;
Add: List<Baum(leer), Baum(addedKnoten)>;
Add: List<Baum(leer), Baum(addedKnoten, newAddedKnoten), Baum(addedKnoten, newAddedKnoten)>; ---- richtig wäre: List<Baum(leer), Baum(addedKnoten), Baum(addedKnoten, newAddedKnoten)>;

Quellcode:

public void baum_add(Data dnew)
{
	binbaum.add(dnew);
	final Baum newbaum = binbaum.clone();
	binaerbaeume.add(newbaum);
} // Im GUI


protected Baum clone()
{
	try
	{
		return (Baum) super.clone();
	}
	catch(CloneNotSupportedException e)
	{
		System.err.println(e);
		return null;
	}
} // In Baum

 

[faetzminator]

Du musst natürlich die Methode [c]clone()[/c] noch implementieren, z.B. so:

protected Baum clone() throws CloneNotSupportedException {
    Baum clone = new Baum();
    // danach die Attribute oder was weiss ich
    clone.someInt = this.someInt;
    clone.someString = this.someString; // immutable object, darum einfach zuweisen
    clone.someOtherObject = this.someOtherObject.clone(); // nicht immutable, darum auch dort clone() aufrufen falls eine Veränderung erwartet wird
    // ...
    return clone;
}

 

[Mujahiddin]

Okay, jetzt klappts, danke schön