# InfixtoPostfix Aufgabe



## Leuchtturm (25. Mai 2010)

Hallo, ich habe die Aufgabe einen Wert der in Infix vorliegt mithilfe eines Stacks in Postfix umzuwandeln, dass ganze soll mittels einer Methode passiere.
Ich habe die Methode schon sogut wie fertig aber ich schaffe es nicht in der Methode ein neuen Stack anzulegen in den dann die Operatoren zwischen gespeichert werden. 

Hier meine Methode: 


```
public void infixToPostfix() throws StackException {
   if (size == 0) {
     throw new StackException("Stack empty"); }
     
    LinkedListStack tmp = new LinkedListStack(); // irgendwas Klappt hier nicht 
     
    for (int i = 0; i < size; i++) {
     try {   
      if(this.top().equals('(')) {               
         this.pop();
     }
     if(this.top().equals(')')) {
       System.out.print(tmp.top());
       System.out.print(" ");
       tmp.pop(); 
      
     }
     if(this.top().equals('/')) {
        tmp.push(this.top());         // hier vermute ich auch einen Fehler
        this.pop();
    }
      if(this.top().equals('*')) {
        tmp.push(this.top());
        this.pop();
        
    }
      if(this.top().equals('-')) {
        tmp.push(this.top());
        this.pop();
    }
      if(this.top().equals('+')) {
        tmp.push(this.top());
        this.pop();
    }
      if(this.top().equals('%')) {
        tmp.push(this.top());
        this.pop();
    }
    else
       System.out.print(this.top());
       System.out.print(" ");
       System.out.print(tmp.top());
       this.pop();
  
    } catch (StackException e) {
    }
  }
}
```

Die Klasse in der die Methode steht sieht so aus: 
(Da die anderen Methoden funktionieren nur der Kopf mit dem wichtigsten)


```
public class LinkedListStack<T> {
                           

  class ListElement<T> {
    private T item;
    private ListElement<T> next;
    
    ListElement(ListElement<T> next, T item) {
      this.next=next;
      this.item=item;
    }
    
    T getItem() {
      return item;
    }
    
    ListElement<T> getNext() {
      return next;
    }
  }

  private ListElement<T> first = null;

  private int size = 0;

  public boolean isEmpty() {
    return size == 0;
  }

  public int size() {
    return size;
  }
```

Ich hoffe ihr könnt mir sagen wie ich es doch noch schaffe ein neuen Stack zu erstellen und so
meine Methode zum laufen bekomm


----------



## SlaterB (25. Mai 2010)

> // irgendwas Klappt hier nicht 

gehts genauer?

versuche folgendes neue Programm:

```
public class Test
{
    public static void main(String[] args)
    {
        System.out.println("start");
        LinkedListStack tmp = new LinkedListStack();
        System.out.println("tmp: " + tmp);
        System.out.println("ende");
    }
}
```
Ausgabe? Fehlermeldung?


----------



## Leuchtturm (25. Mai 2010)

Keine Fehlermeldung! 

Ausgabe: 
start
tmp: Keller:
ende


Wie gesagt, dass Problem liegt daran das der neuerstellte Stack nicht funktioniert!


----------



## SlaterB (25. Mai 2010)

definiere 'nicht funktionieren'

am besten in einem vollständigen Programm


----------



## Leuchtturm (25. Mai 2010)

Es wird halt kein neuer Stack angelegt und auch nix gespeichert bzw. wieder ausgelesen! 
Was soll ich dazu mehr sagen.....


----------



## SlaterB (25. Mai 2010)

na ein Programm muss doch verläßlich prüfbare Ergebnisse liefern,
siehe mein Programm, da zeigt die Ausgabe 'tmp: Keller:' messerscharf, dass ein Stack erzeugt wurde

wie prüfst du das in deinem Programm, wonach richtet sich dein Gefühl, ob etwas richtig oder falsch ist,
irgendwo muss doch eine Ausgabe oder ähnliches stattfinden,
diese Stelle ist dann interessant


----------



## Leuchtturm (25. Mai 2010)

Also, dass Problem liegt darin, dass bei folgenden Aufrufen immer nur ein Element im Stack gespeichert wird.


```
public void infixToPostfix() throws StackException {
   if (size == 0) {
     throw new StackException("Stack empty"); }
     
   LinkedListStack tmp = new LinkedListStack();
     
    for (int i = 0; i < size; i++) {      
     try {   
      if(this.top().equals('(')) {
         this.pop();
     }
     if(this.top().equals(')')) {
       System.out.print("tmp top: " +tmp.top());
       System.out.print(" test ) ");
       tmp.pop(); 
     }
    
     if(this.top().equals('/')) {
          System.out.print(" test / ");
        tmp.push(this.top());              // Bei allen diesen Aufrufen wird wenn z.B. als
        System.out.println(tmp);        // test //// eingegeben wird nur ein Stack mit einen /
        this.pop();                          // angelegt.  
       
    }
      if(this.top().equals('*')) {
          System.out.print(" test * ");
        tmp.push(this.top());
        this.pop();
        
    }
      if(this.top().equals('-')) {
          System.out.print(" test - ");
        tmp.push(this.top());
        this.pop();
    }
      if(this.top().equals('+')) {
        System.out.print(" test + ");
        tmp.push(this.top());
        this.pop();
    }
      if(this.top().equals('%')) {
        System.out.print(" test % ");
        tmp.push(this.top());
        this.pop();
    }
    else
   
       System.out.print(this.top());
       System.out.print(" ");
       this.pop();
  
    } catch (StackException e) {
    }
  }
}
```

Kann mir jemand sagen warum der neue Stack bei jedem Schleifendurchlauf neu Implementiert wird?


----------



## SlaterB (25. Mai 2010)

günstig wäre wirklich ein vollständiges Programm mit main-Methode, allein schon mit einem vorher gefüllten Stack, der umzumappen ist,

deine System.out.println()-Ausgaben helfen nicht? 
versuche genau auszugeben, welchen Zustand der eine oder gar beide Stacks vor der Schleife, zu Beginn und Ende jeden Durchlaufs haben,
welche if-Abschnitte aktiviert wurden und was genau die warum ändern


----------



## Leuchtturm (25. Mai 2010)

Also, der this Stack läuft super aber beim tmp werden die Elemente halt nach jedem durchlauf wieder gelöscht und nicht wie gewollt gespeichert bis sie aufgerufen werden. Sonst gibt es eigentlich kein Problem.


----------



## SlaterB (25. Mai 2010)

und wie kommt es dazu, schau dir alle möglichen Methoden an, die dafür in Frage kommen, z.B. ja die pop()-Methode,
schreibe dort eine Ausgabe rein a la
System.out.println("pop() dran, auf Stack "+hashCode()+", vorher waren es ... Elemente, nun ..");
hashCode() ist eine gute Möglichkeit, mehrere Objekte einer Klasse zu unterscheiden, beim this-Stack rufst du ja korrekterweise regelmäßig pop() auf, aber anscheinend auch beim anderen,

wenn du das durch diese Ausgabe festgestellt hast, dann schaue dir alle vorhandenen Aufrufe der pop()-Methode im Programm an,
besonders verdächtig ist natürlich Zeile 15 in deinem Posting von 18:41, aber da hast du ja schon eine Ausgabe,
das müsstest du doch merken wenn das zuoft (immer) ausgeführt wird,
vielleicht gibts noch andere, jedenfalls sollte es doch einfach möglich sein, herauszufinden, wann das wo warum passiert,


bist du dir überhaupt sicher, dass das in einem Schleifendurchlauf passiert und du nicht vielmehr mehrere Male die Methode aufrufst mit immer neuen tmp-Objekt?

> for (int i = 0; i < size; i++) {   
ist dahingehend schon ziemlich mies, viel besser wäre


```
System.out.println("jetzt kommt die infixToPostfix-Schleife, size ist: "+size);
for (int i = 0; i < size; i++) {   
   System.out.println("Schleifendurchlauf i = .. von size = .. dran, eigener Stack hat Anzahl Elemente .., tmp hat .. Elemente");
```
usw., das Programm erzählt dir gerne jeden einzelnen Schritt, du musst nur fragen

----

} catch (StackException e) {
    }

sieht auch übel aus, du kriegst überhaupt nix von einer Exception mit


----------



## Leuchtturm (25. Mai 2010)

Hab mir das mal alles so angeschaut und irgendwie läuft das nicht so wie ich mir das vorgestellt habe


----------

