# reverseStack



## Sduni (12. Jan 2010)

folgendes Sache:


```
Stack result = new Stack();
result = this;
while(!this.isEmpty()){
	this.pop();
}
while(!result.isEmpty()){
	this.push(result.pop());
}
```

Wrapper.java:157: push(E) in Wrapper.Stack<E> cannot be applied to (java.lang.Object)
this.push(result.pop());
....^
1 error



Ihr befindet euch in dieser Aufgabe innerhalb der
  Klasse Stack<E> und könnt auf die
  Instanzvariablen und Instanzmethoden direkt oder mit this
  zugreifen.


  Da euch die Klasse Stack<E> nicht alle Zeiger zur
  Verfügung stellt, wie die Klasse
  SimpleList<T> (vergleiche Aufgabe 9
  reverse() auf OA-Blatt 9.1), müsst ihr euch selber
  darum kümmern, diese Zeiger zu erhalten.

warum funzt mein Code nicht? this ist doch der Ausgangsstack?


----------



## Gastredner (12. Jan 2010)

this ist die Referenz auf deine Klasse - und wenn das kein Stack ist bzw. nciht von Stack erbt, dann kannst du darauf auch keine Methode eines Stack-Objektes aufrufen.
Außerdem verweist auch die Variable result durch deine Zuweisung von this auf deine Klasse und nicht mehr auf den zuvor angelegten Stack.


----------



## SlaterB (12. Jan 2010)

tja, in diesem Fall deuet es darauf hin, dass die Klasse von this doch ein Stack ist, sogar mit generischen Parameter,
und result.pop() liefert, nicht generisch, nur ein Object, das passt nicht zusammen

Stack<E> result = new Stack<E>();
result = this;

oder besser
Stack<E> result = null;
result = this;

oder gleich
Stack<E> result = this;

würde zu keinem Compilerfehler mehr führen,
der Sinn dieser Befehle will sich aber nicht zu erkennen geben

this und result sind nach dem Code exakt dasselbe,
die zweite while-Schleife wird nix machen, da this == result leer ist dank der ersten Schleife
und selbst wenn, wieso aus ein und denselben Objekt etwas rausnehmen und gleich wieder einfügen?


----------



## Sduni (12. Jan 2010)

wie kann man den einen Stack clonen?

folgende Methoden der Klasse Stack und ListNode darf ich nutzen:

Generated Documentation (Untitled)


----------



## SlaterB (12. Jan 2010)

z.B. alle Elemente aus dem einen Stack herausnehmen, in einer Liste speichern und am Ende in richtiger Reihenfolge bei beiden wieder einfügen,
ohne direkte Zwischenspeicherung hilft Rekursion als Trick, aber kompliziert, wenn man es noch nicht kennt

das schlimmste ist erstmal
result = this;
wenn es nur ein statt zwei Objekte gibt, kann man kaum eine Kopie (= was anderes) erstellen


----------



## Sduni (12. Jan 2010)

Wie wäre es dann mit Rekursion? Also wie würde das mit meiner Aufgabe funktionieren?
Ich habs jetzt nicht rekursiv gemacht, sondern:


```
Stack<E> temp = new Stack<E>();
Stack<E> result = new Stack<E>();
while(!this.isEmpty()){
	temp.push(this.pop());
}
while(!temp.isEmpty()){
	result.push(temp.pop());
}
while(!result.isEmpty()){
	this.push(result.pop());
}
```

Würde gerne aber trotzdem die rekursive Methode wissen?


----------



## Landei (13. Jan 2010)

(ungetestet)


```
Stack<E> copy() {
   return copyLoop(this);
}

private Stack<E> copyLoop(Stack<E> stack) {
   if(stack.isEmpty()) {
        return new Stack<E>(); 
   } else {
      E e = stack.pop();
      Stack<E> clone = copyLoop(stack);
      stack.push(e);
      clone.push(e);
      return clone;
   }
}
```


----------



## SlaterB (13. Jan 2010)

@Sduni
das mit dem Temp-Stack ist aber auch gut, daran dachte ich gar nicht,
so wie um 21.16 gestern wirds aber kaum funktionieren, da ist result am Ende ja leer,

in der zweiten Schleife temp.pop() in einer Variablen speichern und dann sowohl bei result als auch this wieder einfügen,
die dritte Schleife weg


----------



## Sduni (13. Jan 2010)

Vlt. sollte ich dazu sagen, dass der Methodenkopf void ist  also

public void reverse(){
}

Es muss also nur this verändert werden, quasi zwei Hilfsstacks.


----------

