# Queue programmieren via BlueJ



## Layer7 (15. Okt 2013)

Guten Abend,

momentan bin ich dabei, eine Queue zu programmieren, welche aus einzelnen Knoten besteht, die wiederum jeweils mit Inhalt gefüllt sind - soweit so gut, doch erhalte ich noch die eine oder andere Fehlermeldung, auch bin ich mir nicht sicher, ob die Funktion, welche die Elemente der Schlange zählen soll, funktioniert.

Klassen:

Person - beinhaltet lediglich einige für die eigentliche Fragestellung irrelevante Variablen
Node   - Element der Schlange
Queue - Hauptklasse, welche eigentliche Operationen ausführt.

Hier der Quelltext:

Node (hier treten meines Erachtens nach noch keine Probleme auf)

```
public class Node
{
    private Person inhalt;
    private Node next;
   

    public Node(person p)
    {
        inhalt = p;
    }

    public void setNext(Node n) {
        next = n;
    }
    
    public Node giveNext() {
        return next;
    }
    
    public Person returnInhalt(Node n) {
        return inhalt;
    }

}
```


Queue:


```
public class Queue
{

    public Node start;
    public Node end;
    public int counter = 0;
    private int anfangsCounter = 0;

    public Schlange()
    {

    }

    public void enqueue(Node n) { 
        if(start==null&&end==null) {
            start = new Node;
end = new Node;
        }

        else {
            start = new Node;
        }
    }
//Anmerkung zu enqueue: Hier soll ein neuer Knoten an den Anfang gesetzt werden, jedoch                                                      //wird die Fehlermeldung ") or ] expected" ausgegeben.

    public void dequeue(Node n) {
        if(start==null&&end==null) {

        }

        else {
            if(start!=end) {
                start=n.gibNachfolger();
            }
if(start==end) {
start == null;
end == null;
}
        }
    }
//Anmerkung zu dequeue: das erste Element der Schlange soll entfernt werden, hier wird keine Fehlermeldung ausgegeben.


    public boolean einElement() {
        if(start==end&&start!=null) {
            return true;
        }

        else {
            return false;
        }
    }

    public boolean leer() {
        if(start==null&&end==null) {
            return true;
        }

        else {
            return false;
        }
    }

//Anmerkung zu leer und einElement: es wird überprüft, ob ein oder kein Element in der Schlange //vorhanden ist.

    public void count(Node n) {
        if(anfangsCounter = 0) {
            start = end;
            start=n.giveNext();
            counter ++;
            anfangsCounter ++;
        }

        if(anfangsCounter!=0) {
            if(start!=k) {
                start = end;
               start=n.giveNext();
                counter ++;
                Queue.count();
            }

            else {
                return counter;
            }
        }

    }

}
//Anmerkung zu count: Die Anzahl der Elemente der Schlange soll geprüft werden.
//Meine Idee besteht darin, dass der Anfang der Queue kontinuierlich ans Ende gesetzt wird und //daraufhin der Nachfolger des Anfangs der neue Anfang wird, pro Aktion wird ein Counter erhöht, //welcher die Anzahl der Elemente angibt.
//Da die Funktion darauf beruht, dass der jeweilige Anfang nicht n ist, habe ich den anfangsCounter //eingeführt, der dafür sorgt, dass der Vorgang beim ersten mal auch dann ausgeführt wird, wenn //Anfang und Ende übereinstimmen.
//Schlange.count() soll die Funktion solange aufrufen, bis der Anfang wieder mit n übereinstimmt, //jedoch wird hier die Fehlermeldung "Method in class Queue cannot be applied to given types; //requiered: node; found: no arguments; reasons: actual and formal arguments lists differ in length" //ausgegeben."
```



Über jegliche Hilfe würde ich mich sehr freuen


----------



## Ruzmanz (15. Okt 2013)

Konstruktor und Klassennamen sind unterschiedlich.


```
public Schlange()
    {
 
    }
```

Neue Objekte werden durch einen Konstruktoraufruf erzeigt. Deshalb sind die Klammern notwendig.


```
start = new Node();
```

Es gibt keine count()-Methode ohne Parameter. Zudem müsste sie static sein, wenn du sie über die Klasse aufrufst.

```
Queue.count();
```

Warum machst du nicht, sowas wie: (Nur ein Beispiel, kein funktionsfähiger Code)


```
cnt = 0;

while(Node.hatNachfolger?) {
   cnt++;
}

return cnt;
```

Wenn void als Rückgabewert angegeben ist, kannst du keinen Integer zurückgeben.


```
return counter;
```


----------



## Bqg_stylo (15. Okt 2013)

Zeile 67 
	
	
	
	





```
if(anfangsCounter = 0) {
```
 ist so sicher nicht gewünscht.


----------



## Layer7 (16. Okt 2013)

Erstmal danke für die schnellen Antworten.

Ich habe bereits einige Probleme beseitigt, doch momentan komme ich bei der count-Methode nicht weiter:


Queue

```
public class Schlange
{

    public Node start;
    public Node end;
    public int counter = 0;
           private int zahl = 0;

    public Schlange()
    {

    }

  

    public int count(Node n) {
        if(zahl==0) {
            start=n;
            zahl++;
        }
        if(zahl!=0) {
            while(start.hatNachfolger()==true) {
                counter++;
                start=n.gibNachfolger();
              
            }
           
        }
        return counter;
    }
}
```

Node:

```
public class Node
{
    private person inhalt;
    public Node naechster;

   

    public Knoten(person p)
    {
        inhalt = p;
    }

    public void setzeNachfolger(node n) {
        naechster = n;
    }

    public Knoten gibNachfolger() {
        return naechster;
    }

    public boolean hatNachfolger() {
        if(naechster!=null) {
            return true;
        }

        else {
            return false;
        }
    }

    public person gibInhalt(node n) {
        return inhalt;
    }

    
}
```

Alles lässt sich kompilieren, führe ich jedoch die count-Funktion aus, rechnet der PC scheinbar in einer Endlosschleife, kein Ergebnis wird angezeigt.


----------



## Ruzmanz (16. Okt 2013)

- Um die Größe der Schlange zu ermitteln brauchst du keine Parameter.
- Die Endlosschleife tritt auf, weil du immer dein Startelement auf "n.gibNachfolger()" setzt. Der gibt die endlos den Nachfolger von deinem n-Element zurück.


```
public int count() {
        if(zahl==0) {
            start=n; // Fehler, da n fehlt.
            zahl++;
        }
        if(zahl!=0) {
            while(start.hatNachfolger()==true) {
                counter++;
                start=n.gibNachfolger(); // Fehler, da n fehlt.
             
            }
           
        }
        return counter;
    }
```


- Die Größe deiner Schlange ermittelst du, indem du alle Elemente ab deinen Startpunkt zählst. Der Startpunkt ist bereits bekannt.
- Dort gehst du immer weiter bis zum nächsten Knoten


```
public int count() {
        Node node;

        if(zahl==0) {
            node = start; // Von Anfang an beginnen.
            zahl++;
        }
        if(zahl!=0) {
            while(node.hatNachfolger()) { // Gibt bereits true/false zurück, deshalb muss man das nicht mit == true gegenprüfen.
                counter++;
                node = node.gibNachfolger(); // Setzt die Node auf das nächste Element.
            }
           
        }
        return counter;
    }
```

- Die Instanzvariable zahl wird nicht benötigt. Das können simple Abfragen erledigen.


```
public int count() {
        Node node;

        if(start != null) {
            node = start;
            counter++;

            while(node.hatNachfolger()) {
                counter++;
                node = node.gibNachfolger();
            }
        }
        return counter;
    }
```

- Da du eine Count-Methode hast und nicht beim Hinzufügen / Löschen den Wert von counter veränderst, brauchst du sie nicht als Instanzvariable.


```
public int count() {
        Node node;
        int counter = 0;

        if(start != null) { // Zähle nur, wenn es ein Startelement gibt, ansonsten ist der counter 0.
            node = start;
            counter++;

            while(node.hatNachfolger()) {
                counter++;
                node = node.gibNachfolger();
            }
        }
        return counter;
    }
```


----------



## Layer7 (16. Okt 2013)

Danke für Deine Hilfe, habe es nun endlich verstanden


----------

