# Stack programmieren



## JavaIsTheBest (15. Mai 2016)

Hallo,
ich habe eine Aufgabe, bei der ich Stacks programmieren soll.
Beim Testen haben die Methoden pop() und swap() nicht funktioniert. Selbst nach dem Debuggen, hab ich den Fehler nicht rausbekommen.
Hier sind zusammengefasst all meine Fragen.

1. Warum funktioniert die Methode pop() nicht?
2. Warum funktioniert die Methode swap() nicht?
3. Warum meldet der Compiler einen Fehler, wenn ich diese Zeile hinschreibe: stack[card-1]=null;    ?
4. In der Musterlösung steht für die Funktion pop folgender Code:  public double pop () { return elems[−−top]; }
    a) Was wird hier gemacht? Das Element elems[top+1] wurde doch nicht gelöscht. Es wurde    nur die Kardinalität um eins verringert. Aber das Element steht trotzdem drin.
5. Warum konnte ich in der *Klasse VerboseStack*, die Methoden pop() und push() nicht so definieren: public void push()/public void pop()? 



Spoiler: Stack





```
public class Stack {
    protected int size;
    protected int card; //Anzahl der tatsächlichen Elemente
    protected double[] stack;
   
    public Stack(int n){
        stack=new double[n];
        size=n;
    }
    public boolean push(double x){
        if(card<size){
            stack[card]=x;
            card++;
            return true;
        }
        return false;
    }
    public double pop(){
        double tmp=stack[card-1];
        //stack[card-1]=null; Warum funktioniert das nicht?
        card--;
        return tmp;
    }
    public boolean swap(){
        if(card<2){
            return false;
        }
        double tmp1=pop();
        double tmp2=pop();
        push(tmp1);
        push(tmp2);
        return true;
    }
    public String toString(){
        String s="";
        if(card==0){
            return s;
        }
        s+=stack[0];
        for(int i=1;i<card;i++){
            s+=", "+stack[i];
        }
        return s;
    }
}
```






Spoiler: DecreasingStack





```
public class DecreasingStack extends Stack {
   
    public DecreasingStack(int n){
        super(n);
    }
    // Nur das oberste Element muss überprüft werden
    public boolean push(double x){
        if(card<size && x<stack[--card]){
            stack[card]=x;
            card++;
            return true;
        }
        return false;
    }
   
    public boolean swap(){
        return false;
    }
   

}
```






Spoiler: VerboseStack





```
public class VerboseStack extends Stack{
    //final?
    static int number=0;
   
    public VerboseStack(int n){
        super(n);
        number++;
    }
    public boolean push(double x){ //Geht auch public void push() ?
        if(!super.push(x)){
            return false;
        }
        System.out.print("Stack no. "+number+": "+"push "+x);
        return true;
    }
    public double pop(){ //Geht auch public void pop() ?
        double x=super.pop();
        System.out.println("Stack no. "+number+": "+"pop "+x);
        return x;
    }
   

}
```






Spoiler: StackTest





```
public class StackTest {

    public static void main(String[] args) {
        Stack s =new Stack(4);
       
        s.push(3.3);
        s.push(3.1);
        s.push(3.3);
        s.push(5.7);
       
        s.swap();
       
        System.out.println(s.toString());
       
       
        s.pop();
        System.out.println(s.toString());
    }

}
```


----------



## JCODA (15. Mai 2016)

1. Warum funktioniert die Methode pop() nicht?
_Bei mir klappt's. Wie kommst du drauf, dass es nicht klappt? Testcode?_

2. Warum funktioniert die Methode swap() nicht?
_Bei mir klappt's. Wie kommst du drauf, dass es nicht klappt? Testcode?_


3. Warum meldet der Compiler einen Fehler, wenn ich diese Zeile hinschreibe: stack[card-1]=null; ?
_double ist ein primitiver Typ. Hier gibt es kein "null". Es gibt nur den Wert null: 0.0 (die Werte im Array sind anfangs auch 0.0) _

4. In der Musterlösung steht für die Funktion pop folgender Code: public double pop () { return elems[−−top]; }
a) Was wird hier gemacht? Das Element elems[top+1] wurde doch nicht gelöscht. Es wurde nur die Kardinalität um eins verringert. Aber das Element steht trotzdem drin.
_Ja, das ist auch nicht schlimm, dass das Element noch drin ist, solange die card/bzw. größe verändert wird, greift ja auch niemand mehr darauf zu._

5. Warum konnte ich in der *Klasse VerboseStack*, die Methoden pop() und push() nicht so definieren: public void push()/public void pop()? 
_push ohne Rückgabewert und Parameter? Warum? du möchtest ja die Funktionsweise eines normalen Stacks nicht verlieren. Außerdem war hier wohl der Sinn der Aufgabe, die Methoden zu überschreiben, deswegen müssen diese die gleiche Signatur aufweisen. _


----------



## JavaIsTheBest (15. Mai 2016)

Jetzt auf einmal gehen die Funktionen. Vielleicht musste ich eclipse nur neu starten.
Jedenfalls, hatte ich in meinem Code ein paar Fehler und hab diese korrigiert. Das Testen ging diesmal auch problemlos.
Findet ihr Fehler?



Spoiler: stack





```
public class Stack {
    protected int size;
    protected int card; //Anzahl der tatsächlichen Elemente
    protected double[] stack;
   
    public Stack(int n){
        stack=new double[n];
        size=n;
    }
    public boolean push(double x){
        if(card<size){
            stack[card]=x;
            card++;
            return true;
        }
        return false;
    }
    public double pop(){
        double tmp=stack[card-1];
        stack[card-1]=0.0; //stack[card-1]=null; -> Falsch
        card--;
        return tmp;
    }
    public boolean swap(){
        if(card<2){
            return false;
        }
        double tmp1=pop();
        double tmp2=pop();
        push(tmp1);
        push(tmp2);
        return true;
    }
    public String toString(){
        String s="";
        if(card==0){
            return s;
        }
        s+=stack[0];
        for(int i=1;i<card;i++){
            s+=", "+stack[i];
        }
        return s;
    }
}
```






Spoiler: decreasingstack





```
public class DecreasingStack extends Stack {

    public DecreasingStack(int n) {
        super(n);
    }

    // Nur das oberste Element muss überprüft werden
    public boolean push(double x) {
        if (card > 0 && x > stack[card - 1]) {
            return false;
        }
        stack[card] = x;
        card++;
        return true;
    }

    public boolean swap() {
        return false;
    }

}
```






Spoiler: verbosestack





```
public class VerboseStack extends Stack{
    //final?
    static int number=0;
   
    public VerboseStack(int n){
        super(n);
        number++;
    }
    public boolean push(double x){ //Geht auch public void push(double x) ? Nein, da push(double x) aus der Oberklasse einen boolean zurückgibt -> incompatible
        if(!super.push(x)){
            return false;
        }
        System.out.println("Stack no. "+number+": "+"push "+x);
        return true;
    }
    public double pop(){ //Geht auch public void pop() ? Nein, da pop() aus der Oberklasse einen double zurückgibt -> incompatible
        double x=super.pop();
        System.out.println("Stack no. "+number+": "+"pop "+x);
        return x;
    }
   

}
```






Spoiler: stacktest





```
public class StackTest {

    public static void main(String[] args) {
        Stack s =new Stack(4);
       
        s.push(3.3);
        s.push(3.1);
        s.push(3.3);
        s.push(5.7);
        System.out.println(s.toString());
       
        s.swap();
        System.out.println(s.toString());
       
        s.pop();
        System.out.println(s.toString());
       
        VerboseStack v=new VerboseStack(4);
        v.push(3);
        v.push(2);
        v.pop();
       
        VerboseStack v2=new VerboseStack(4);
        v2.push(4);
        v2.push(6);
        v2.pop();
       
        DecreasingStack d=new DecreasingStack(5);
        d.push(3);
        d.push(2);
        d.push(2.1);
        System.out.println(d.toString());
       
        d.swap();
        System.out.println(d);
    }

}
```


----------

