Datenstrukturen/ Listen

[Louis12]

Hallo Java Community,

Könnt ihr bitte meine Fragen Beantworten zu folgender Aufgabenstellung


Erstmal die Allgemeine Aufgabenstellung :In dieser Aufgabe werden Sie eine für die Lieferungen optimierte Datenstruktur implementieren.

Die Aufgabe mit der Frage:

Erstellen Sie im Package de.tuberlin.mcc.prog1.logistics.store eine Klasse ShippableQueue, welche das Interface IShippableQueue (ebenfalls im Package) implementiert.

Fügen Sie anschließend der Klasse die Instanzvariablen firstElement, lastElement (beide vom Typ QueueElement) und size (Typ int) hinzu.

Realisieren Sie in dieser Klasse eine doppelt verkette Liste, indem Sie die geforderten Methoden entsprechend der gegebenen Spezifikationen in der Javadoc-Kommentierung der Schnittstelle IShippableQueue implementieren.

Achten Sie darauf, die Instanzvariable size immer auf dem aktuellen Stand zu halten, wenn Elemente hinzugefügt oder entfernt werden.

Realisieren Sie in dieser Klasse eine doppelt verkette Liste, indem Sie die geforderten Methoden entsprechend der gegebenen Spezifikationen in der Javadoc-Kommentierung der Schnittstelle IShippableQueue implementieren.

Angenommen ich habe die Methoden implementiert soll ich dann ein Objekt benutzen um die Instantzveriablen zu speichern. und sie dann noch mehr Methoden ergänzen wo in der Methode steht z.B.
this.nextElem = nextElem; ?

Wäre nett, wenn jemand mir auf die Sprünge hilft.

lG
Louis

 

[httpdigest]

soll ich dann ein Objekt benutzen um die Instantzveriablen zu speichern. und sie dann noch mehr Methoden ergänzen wo in der Methode steht z.B.
this.nextElem = nextElem; ?

Sorry, ich weiß nicht, wie viele grammatikalische Fehler in diesen Sätzen sind, aber es sind genug, dass ich sie inhaltlich nicht mehr verstehe. "Und sie dann noch mehr Methoden ergänzen wo in der Methode steht..." WAS?

 

[MoxxiManagarm]

Angenommen ich habe die Methoden implementiert soll ich dann ein Objekt benutzen um die Instantzveriablen zu speichern. und sie dann noch mehr Methoden ergänzen wo in der Methode steht z.B.
this.nextElem = nextElem; ?

Du sollst
1. Die Klasse erstellen
2. Die Klasse das Interface implementieren lassen (das Interface ist bereits vorhanden)
-> eine IDE wird sofort meckern, dass es unimplementierte Methoden gibt, welche durch das Interface bestimmt sind
3. Die genannten Instanzvariablen in der Klasse aus 1. ergänzen
4. Die Methoden aus 2) ausformulieren

 

[Louis12]

Hallo,
Danke für die Antworten erstmal.

Sorry, ich weiß nicht, wie viele grammatikalische Fehler in diesen Sätzen sind, aber es sind genug, dass ich sie inhaltlich nicht mehr verstehe. "Und sie dann noch mehr Methoden ergänzen wo in der Methode steht..." WAS?

Ich versuche das nächste Mal es besser zu machen .

Du sollst
1. Die Klasse erstellen
2. Die Klasse das Interface implementieren lassen (das Interface ist bereits vorhanden)
-> eine IDE wird sofort meckern, dass es unimplementierte Methoden gibt, welche durch das Interface bestimmt sind
3. Die genannten Instanzvariablen in der Klasse aus 1. ergänzen
4. Die Methoden aus 2) ausformulieren

Ich glaube das jetzt hinbekommen, Ist das jetzt richtig?.

package de.tuberlin.mcc.prog1.logistics.store;

import javax.swing.text.StyledEditorKit.ForegroundAction;

import de.tuberlin.mcc.prog1.logistics.deliveries.Shippable;

public class ShippableQueue implements IShippableQueue {
 
private QueueElement firstElement;
private QueueElement lastElement;
private int  size;
 
 
 
 
 
 

    @Override
    public void enqueue(Shippable shippable) {
        // TODO Auto-generated method stub
     
    }

    @Override
    public Shippable dequeue() {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public Shippable dequeue(Shippable shippable) {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public Shippable getFirst() {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public Shippable getLast() {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public Shippable get(Shippable shippable) {
        // TODO Auto-generated method stub
        return null;
     
    }

    @Override
    public Shippable[] getAll() {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public int size() {
        // TODO Auto-generated method stub
        return size() ;
    }

 
}

 

[MoxxiManagarm]

Ja das schaut erstmal gut aus. Jetzt musst du den Methoden Leben einhauchen

 

[Louis12]

Hallo,
ich habe die Methoden ergänzt und würde mich über Feedback freuen 🙂 außerdem hätte ich noch einige Fragen .

Hier ist erstmal der Code.

package de.tuberlin.mcc.prog1.logistics.store;

//import javax.swing.text.StyledEditorKit.ForegroundAction;

import de.tuberlin.mcc.prog1.logistics.deliveries.Shippable;

public class ShippableQueue implements IShippableQueue {
   
private QueueElement firstElement;
private QueueElement lastElement;
private int  size;
   
   
   
   
/**
* Enqueues a given shippable at the end of this queue
*/
   

    @Override
    public void enqueue(Shippable shippable) {
        // soll hier eine Art Liste hinzugrfügt werden
        // return wert ist ja void
    }
/**
* Retrieves and removes the head of this queue, or returns null if this queue is empty.

*/
    @Override
    public Shippable dequeue() {
        if(firstElement != null) {
            return (Shippable) firstElement;

        }
        else {
            return null;
        }
    }

/**
* Retrieves and removes the given shippable if it is contained in this queue, or returns null if not.
   
*/
    @Override
    public Shippable dequeue(Shippable shippable) {
        // TODO Auto-generated method stub
        if(shippable != null) {
            return shippable;
        }else {
            return null;
        }
    }
/**
* Retrieves, but does not remove, the head of this queue, or returns null if this queue is empty.
*
*/

    @Override
    public Shippable getFirst() {                   
        // TODO Auto-generated method stub
        if(firstElement != null) {
            return (Shippable) firstElement;

        }
        else {
            return null;
        }
    }
/**
* Retrieves, but does not remove, the tail of this queue, or returns null if this queue is empty.
*/

    @Override
    public Shippable getLast() {
        // TODO Auto-generated method stub
        if(lastElement != null) {
            return (Shippable) lastElement;

        }
        else {
            return null;
        }
    }
   
/**Retrieves, but does not remove, the given element if it is contained in this queue, or returns null if not.
*
*/

    @Override
    public Shippable get(Shippable shippable) {
        // TODO Auto-generated method stub
   
        if(firstElement != null && lastElement != null) {
            return new Shippable(firstElement, lastElement); // mit der liste ?
        //    getLast(); oder so ?
        //    getFirst();
        }
       
        else if(firstElement != null  ) {
            return (Shippable) firstElement;
        }else if (lastElement != null) {
            return (Shippable) lastElement;
        }
            else {
                return null;
            }
       
    }
/**
* Retrieves, but does not remove, all shippables inside this queue as array
*/

    @Override
    public Shippable[] getAll() {
        // TODO Auto-generated method stub
       
        Shippable indexshippable = dequeue();
       
        Shippable[] Shippablearray = new Shippable[indexshippable];
       
   
       
        for (int i = 0; i<indexshippable.; i++) {
           
        }
        Shippable[] Shippablearray = dequeue() ;
        return enqueue(Shippable[]);
;
    }
/**
* Returns the current size of queue
*/
    @Override
    public int size() {
        return size ;
    }

   
}

Soll hier eine Liste und dann z.B mit add.(e) etwas hinzugefügt werden, weil der return Wert ist ja void.

/**
* Enqueues a given shippable at the end of this queue
*/
   

    @Override
    public void enqueue(Shippable shippable) {
       
    }

Jedes Element, wenn vorhanden soll ja aufgerufen werden, was tuhe ich wenn alle beide Elemente vorhanden sind?

/**Retrieves, but does not remove, the given element if it is contained in this queue, or returns null if not.
*
*/

    @Override
    public Shippable get(Shippable shippable) {
        // TODO Auto-generated method stub
   
        if(firstElement != null && lastElement != null) {
            return new Shippable(firstElement, lastElement); // mit der liste ?
        //    getLast(); oder so ?
        //    getFirst();
        }
       
        else if(firstElement != null  ) {
            return (Shippable) firstElement;
        }else if (lastElement != null) {
            return (Shippable) lastElement;
        }
            else {
                return null;
            }
       
    }

Soll hier eine Art Liste gecodet werden, wenn nicht dann bitte Tipps geben.

/**
* Retrieves, but does not remove, all shippables inside this queue as array
*/

    @Override
    public Shippable[] getAll() {
        // TODO Auto-generated method stub
       
        Shippable indexshippable = dequeue();
       
        Shippable[] Shippablearray = new Shippable[indexshippable];
       
   
       
        for (int i = 0; i<indexshippable.; i++) {
           
        }
        Shippable[] Shippablearray = dequeue() ;
        return enqueue(Shippable[]);
;
    }

und sehen die Restlichen Methoden gut aus ?.

lG
louis

 

[MoxxiManagarm]

Da ist aber noch einiges verkehrt...

Stell dir einen Zug vor mit einem zughaus vorne und hinten. Beide haben eine Kupplung- firstElement und lastElement. Alle Zugteile (queue element) bestehen aus einem gütercontainer (shipable) und einem zugunterteil auf dem der Container gelagert ist. Dieser Teil hat ebenso eine Kupplung vorne (previous) und hinten (next).

Als Beispiel sei jetzt dequeue genannt. Deine Aufgabe ist den ersten Güterzug auszukoppeln. Der Arbeiter Arbeitet vom zughaus aus an die Kopplung (firstElement) Um den Zug wieder zu einem vollständigen Zug zu machen muss der Arbeiter den Nachfolgezug (next) vom entnommenen Zug (firstElement) zum neuen firstElement machen. Dabei müssen insgesamt 4 kopplungen neu zugewiesen werden: firstElement of head, previous & next of firstElement und previous of firstElement.next.

Du veränderst aktuell auch nicht den Zählstand. Ich glaube auch nicht dass du ein Shipable aus einem QueueElement casten kannst. Shipable ist eher ein Teil eines QueueElement. QueueElement sollte aus dem Shipable, sowie previous und next bestehen. Shipable bekommst du sicherlich mit irgendeinem getter.

 

[MoxxiManagarm]

Ich tippe das gerade vom Handy daher Sorry wenn der Code zur obigen Erläuterung nicht sauber ist:

public Shipable dequeue() {
  // nothing to dequeue
  if (firstElement == null) return null;

  // holding
  QueueElement found = firstElement;

  // restore chain
  firstElement = firstElement.next;
  if (firstElement == null) lastElement = null;
  else firstElement.previous = null;
 
  // van be ignored for this case
  // found.previous = null;
  // found.next = null;

  size--;

  // return value
  return found.getShippable();
}

 

[Louis12]

Hallo,🙂

erstmal Danke für die Ausführliche Antwort .

Dank deinem Beispiel, habe ich es noch besser verstanden.

Stell dir einen Zug vor mit einem Zughaus vorne und hinten.

Kannst du mir sagen, ob das Zughaus vorne und hinten Kopplungen hat, wenn ja kannst du mir evt ein Bild hier rein verlinken, wie das ganze ungefähr aussiehst.

public Shippable dequeue() {
        if(firstElement == null) {
            return null;
        }
         QueueElement found = firstElement;
        
         firstElement = firstElement.getNextElement(); // Wegen dem Code mit Getter kann den auch posten :) 
          if (firstElement == null) lastElement = null;
          else firstElement.setPreviousElement(null);
         
          size--;

          // return value
          return found.getShippable();

Kannst du mir den Teil des Codes erklären bitte.

if (firstElement == null) lastElement = null; coden muss

Hier habe ich es selber versucht anzuwenden

@Override
    public void enqueue(Shippable shippable) {
       
        if(get(shippable) != null) {
             lastElement = lastElement.getNextElement();
        }
         if (lastElement == null) firstElement = null;
         else lastElement.setPreviousElement(lastElement);
          size++;

       
    }

Ich habe auf einer Seite gelesen, das man es sich wie in einer Supermarkt Kasse sich vorstellen kann, allerdings wurde kein next und previous erwähnt, könnte man das Beispiel auch hier übertragen ?.

lG
Louis

 

[mihe7]

Ich habe auf einer Seite gelesen, das man es sich wie in einer Supermarkt Kasse sich vorstellen kann, allerdings wurde kein next und previous erwähnt

Du musst zwischen dem abstrakten Konzept einer Queue und der konkreten Implementierung unterscheiden. Bei einer Queue gibt es zwei Methoden: enqueue und dequeue. Dabei fügt enqueue ein Element in die Queue ein, während dequeue das erste Element aus der Queue entfernt und zurückgibt.

Bei einer Supermarktkasse stellen sich die Leute nacheinander in die Schlange (enqueue). Hat der erste in der Schlange bezahlt, verlässt er die Schlange (dequeue) und der nächste ist an der Reihe. Dass es überhaupt Sinn macht, vom "nächsten" zu sprechen, liegt einfach daran, dass in der Schlange eine Reihenfolge herrscht. Aus dem gleichen Grund lässt sich auch von einem "vorhergehenden" reden.

Wenn Du an den Supermarkt denkst: für jede Person in der Schlange kann angegeben werden, wer vor und wer hinter ihm steht (ggf. ist die Antwort "niemand")

Soviel zum Konzept. Die Frage ist, wie implementiert man nun eine Queue. Würdest Du ein Array verwenden, würde die Anzahl der Elemente im Array reichen; der Rest ist durch die Indizes gegeben. Problem beim Array ist, dass es recht ineffizient arbeitet. Würdest Du z. B. sagen: das erste Element im Array entspricht dem ersten Element in der Schlange, müsstest Du - um das Element zu entfernen - das komplette restliche Array nach vorne verschieben.

Statt einem Array lässt sich eine verkettete Liste verwenden. Dort merkt man sich z. B. das erste Element jedes Element in der Liste kennt das nachfolgende Element.

Beispiel:

       next        next          next
[Hans] ---> [Inge] --->  [Franz] ---> []
  ^
  |
 first

Hier wäre das Entfernen des ersten Elements nun sehr einfach: man merkt sich zunächst einmal das spätere Ergebnis, also das Element, das von first referenziert wird (hier: Hans). Dann ändert man first zu first.next. Bildlich sieht das dann so aus:

       next        next          next
[Hans] ---> [Inge] --->  [Franz] ---> []
  ^           ^
  |           |
 result      first

Abschließend entfernt man noch vom Ergebnis die Nachfolge-Referenz (von Hans auf Inge):

       next        next          next
[Hans] ---> []    [Inge] --->  [Franz] ---> []
  ^                 ^
  |                 |
 result            first

Da über first nur noch zu Inge und über Inge zu Franz navigiert werden kann, besteht die Queue somit nur noch aus Inge und Franz.

Während dequeue() auf diese Weise also sehr effizient implementiert werden könnte, wäre enqueue() mit einigem Aufwand verbunden: man müsste erst alle Elemente durchlaufen, bis man ans Ende der Queue kommt, um dann das Element einfügen zu können. Daher merkt man sich nicht nur das erste, sondern auch das letzte Element. Das hinzuzufügende Element muss dann nur noch beim (zu diesem Zeitpunkt) letzten Element eingeklingt werden (last.next = neuesElement) und die last-Referenz aktualisiert werden (last = neuesElement).

Anmerkung: ich habe nur eine einfach verkettete Liste verwendet. Im Unterschied dazu hast Du eine doppelt verkettete. D. h. jedes Element kennt nicht nur den Nachfolger, sondern auch den Vorgänger.

Jetzt komme ich zu Deiner Frage:

Kannst du mir den Teil des Codes erklären bitte.

Du musst Dir nur klar machen, was passiert, wenn nur noch ein Element in der Queue steht:

          next
  [Franz] ---> []
   ^   ^
   |   |
first last

Wenn dieses nun entfernt wird, dann merkt man sich - wie oben - das first-Element als Ergebnis und überschreibt first durch first.next:

           next
   [Franz] ---> []
    ^   ^        ^
    |   |        |
result last    first

Wie unschwer zu erkennen ist, stimmt die last-Referenz nicht. Die muss ebenfalls auf null gesetzt werden:

           next
   [Franz] ---> []
    ^            ^
    |            |
result      first/last

Und genau deshalb, steht dort:

firstElement = firstElement.getNextElement();
if (firstElement == null) lastElement = null;

Ich hoffe, dass jetzt einiges klarer geworden ist.

 

[Louis12]

Hallo,

Danke für die Ausführliche Antwort, mir ist auf jeden Fall einiges klarer und konnte dementsprechend den Code ergänzen. Zusätzlich habe ich hier die Klasse eingefügt, wo die Setter und Getter sind. Ich hoffe auf weitere Antworten 🙂


Klasse von Setter und Getter.

package de.tuberlin.mcc.prog1.logistics.store;

import de.tuberlin.mcc.prog1.logistics.deliveries.Shippable;

public class QueueElement implements IQueueElement  {

   
private QueueElement previousElement;
private QueueElement nextElement;
private Shippable shippable;
   
   
   
   
    public QueueElement(QueueElement previousElement, QueueElement nextElement, Shippable shippable) {
    super();
    this.previousElement = previousElement;
    this.nextElement = nextElement;
    this.shippable = shippable;
    }

    @Override
    public QueueElement getPreviousElement() {
        // TODO Auto-generated method stub
        return previousElement;
    }

    @Override
    public void setPreviousElement(QueueElement previousElement) {
        // TODO Auto-generated method stub
        this.previousElement = previousElement;
       
    }

    @Override
    public QueueElement getNextElement() {
        // TODO Auto-generated method stub
        return nextElement;
    }

    @Override
    public void setNextElement(QueueElement nextElement) {
        // TODO Auto-generated method stub
        this.nextElement = nextElement;
    }

    @Override
    public Shippable getShippable() {
        // TODO Auto-generated method stub
        return shippable;
    }

Hier der ergäntzte Code. Fragen sind in Kommentare enthalten.

}

package de.tuberlin.mcc.prog1.logistics.store;

//import javax.swing.text.StyledEditorKit.ForegroundAction;

import de.tuberlin.mcc.prog1.logistics.deliveries.Shippable;

public class ShippableQueue implements IShippableQueue {
   
private QueueElement firstElement;
private QueueElement lastElement;
private int  size;
   
   
   
   
/**
* Enqueues a given shippable at the end of this queue
*/
   

    @Override
    public void enqueue(Shippable shippable) {
       
        //shippable = lastElement.getNextElement();
    //    Shippable neuesElement ;
        //QueueElement shippable = new QueueElement(shippable);
        Shippable  last = getLast();      // Bei getlast() wird ja alles durchgegangen wie kann ich jetzt schippaple                                                                // hinzufügen 
    //    last = shippable;
     last.setNextElement(shippable);
    //     last = neuesElement;
       
        size++;
    }
/**
* Retrieves and removes the head of this queue, or returns null if this queue is empty.
7
*/
    @Override
    public Shippable dequeue() {
        if(firstElement == null) {
            return null;
        }
         QueueElement found = firstElement;
        
         firstElement = firstElement.getNextElement();
          if (firstElement == null) lastElement = null;
          else firstElement.setPreviousElement(null);
         
          size--;

          // return value
          return found.getShippable();
    }

/**
* Retrieves and removes the given shippable if it is contained in this queue, or returns null if not.
   
*/
    @Override
    public Shippable dequeue(Shippable shippable) {
        // TODO Auto-generated method stub
        if(shippable != null) {
            return  shippable;
        }else {
            return null;
        }
    }
/**
* Retrieves, but does not remove, the head of this queue, or returns null if this queue is empty.
*
*/

    @Override
    public Shippable getFirst() {                   
        // TODO Auto-generated method stub // Ist das Richtig ? wenn nein bitte Tipps geben
        if(firstElement == null) {
            return null;
        }
         QueueElement fe = firstElement;
        
        
       

          // return value
          return fe.getShippable();
    }

/**
* Retrieves, but does not remove, the tail of this queue, or returns null if this queue is empty.
*/

    @Override
    public Shippable getLast() { //Ist das Richtig ? wenn nein bitte Tipps geben
        // TODO Auto-generated method stub
        if(firstElement == null) {
            return null;
        }
        QueueElement le = firstElement;
        
         while (le.getNextElement() != null) {
                le = le.getNextElement();
            }
        
             return le.getShippable();  //  normalerweise le zurückgegeben
    }

   
/**Retrieves, but does not remove, the given element if it is contained in this queue, or returns null if not.
*
*/

    @Override
    public Shippable get(Shippable shippable) { // Ist das Richtig ? wenn nein bitte Tipps geben
        // TODO Auto-generated method stub
   
        QueueElement le = firstElement;
        if(firstElement == null) {
            return null;
        }else {
            while (le != null) {
                System.out.println(le.getShippable());
                le = le.getNextElement();  
        }
        }
       
        return shippable;
    }
/**
* Retrieves, but does not remove, all shippables inside this queue as array
*/

    @Override
    public Shippable[] getAll() { // kann ich das mit einer for schleife versuchen, wenn ja wie bekomme ich den Index hin, da der Index vom Typ Shippable ist.
//        // TODO Auto-generated method stub
//        QueueElement le = firstElement;
//        while (le != null) {
//            System.out.println(le.getShippable());
//            le = le.getNextElement();   // das ist das Stoppelement
//        }
//        return le.getShippable();
       
        le.getShippable();
       
       
    }
/**
* Returns the current size of queue
*/
    @Override
    public int size() { // hier versucht
        size = 0;
        QueueElement le = firstElement;
       
        while( le != null) {
            size++;
            le.getNextElement();
        }
        return size;
       
    }

   
}

 

[Louis12]

Hallo,

Danke für die Ausführliche Antwort, mir ist auf jeden Fall einiges klarer und konnte dementsprechend den Code ergänzen. Zusätzlich habe ich hier die Klasse eingefügt, wo die Setter und Getter sind. Ich hoffe auf weitere Antworten 🙂


Klasse von Setter und Getter.

package de.tuberlin.mcc.prog1.logistics.store;

import de.tuberlin.mcc.prog1.logistics.deliveries.Shippable;

public class QueueElement implements IQueueElement  {

   
private QueueElement previousElement;
private QueueElement nextElement;
private Shippable shippable;
   
   
   
   
    public QueueElement(QueueElement previousElement, QueueElement nextElement, Shippable shippable) {
    super();
    this.previousElement = previousElement;
    this.nextElement = nextElement;
    this.shippable = shippable;
    }

    @Override
    public QueueElement getPreviousElement() {
        // TODO Auto-generated method stub
        return previousElement;
    }

    @Override
    public void setPreviousElement(QueueElement previousElement) {
        // TODO Auto-generated method stub
        this.previousElement = previousElement;
       
    }

    @Override
    public QueueElement getNextElement() {
        // TODO Auto-generated method stub
        return nextElement;
    }

    @Override
    public void setNextElement(QueueElement nextElement) {
        // TODO Auto-generated method stub
        this.nextElement = nextElement;
    }

    @Override
    public Shippable getShippable() {
        // TODO Auto-generated method stub
        return shippable;
    }

Hier der ergäntzte Code. Fragen sind in Kommentare enthalten.

}

package de.tuberlin.mcc.prog1.logistics.store;

//import javax.swing.text.StyledEditorKit.ForegroundAction;

import de.tuberlin.mcc.prog1.logistics.deliveries.Shippable;

public class ShippableQueue implements IShippableQueue {
   
private QueueElement firstElement;
private QueueElement lastElement;
private int  size;
   
   
   
   
/**
* Enqueues a given shippable at the end of this queue
*/
   

    @Override
    public void enqueue(Shippable shippable) {
       
        //shippable = lastElement.getNextElement();
    //    Shippable neuesElement ;
        //QueueElement shippable = new QueueElement(shippable);
        Shippable  last = getLast();      // Bei getlast() wird ja alles durchgegangen wie kann ich jetzt schippaple                                                                // hinzufügen 
    //    last = shippable;
     last.setNextElement(shippable);
    //     last = neuesElement;
       
        size++;
    }
/**
* Retrieves and removes the head of this queue, or returns null if this queue is empty.
7
*/
    @Override
    public Shippable dequeue() {
        if(firstElement == null) {
            return null;
        }
         QueueElement found = firstElement;
        
         firstElement = firstElement.getNextElement();
          if (firstElement == null) lastElement = null;
          else firstElement.setPreviousElement(null);
         
          size--;

          // return value
          return found.getShippable();
    }

/**
* Retrieves and removes the given shippable if it is contained in this queue, or returns null if not.
   
*/
    @Override
    public Shippable dequeue(Shippable shippable) {
        // TODO Auto-generated method stub
        if(shippable != null) {
            return  shippable;
        }else {
            return null;
        }
    }
/**
* Retrieves, but does not remove, the head of this queue, or returns null if this queue is empty.
*
*/

    @Override
    public Shippable getFirst() {                   
        // TODO Auto-generated method stub // Ist das Richtig ? wenn nein bitte Tipps geben
        if(firstElement == null) {
            return null;
        }
         QueueElement fe = firstElement;
        
        
       

          // return value
          return fe.getShippable();
    }

/**
* Retrieves, but does not remove, the tail of this queue, or returns null if this queue is empty.
*/

    @Override
    public Shippable getLast() { //Ist das Richtig ? wenn nein bitte Tipps geben
        // TODO Auto-generated method stub
        if(firstElement == null) {
            return null;
        }
        QueueElement le = firstElement;
        
         while (le.getNextElement() != null) {
                le = le.getNextElement();
            }
        
             return le.getShippable();  //  normalerweise le zurückgegeben
    }

   
/**Retrieves, but does not remove, the given element if it is contained in this queue, or returns null if not.
*
*/

    @Override
    public Shippable get(Shippable shippable) { // Ist das Richtig ? wenn nein bitte Tipps geben
        // TODO Auto-generated method stub
   
        QueueElement le = firstElement;
        if(firstElement == null) {
            return null;
        }else {
            while (le != null) {
                System.out.println(le.getShippable());
                le = le.getNextElement();  
        }
        }
       
        return shippable;
    }
/**
* Retrieves, but does not remove, all shippables inside this queue as array
*/

    @Override
    public Shippable[] getAll() { // kann ich das mit einer for schleife versuchen, wenn ja wie bekomme ich den                                                       // Index hin, da der Index vom Typ Shippable ist.
//        // TODO Auto-generated method stub
//        QueueElement le = firstElement;
//        while (le != null) {
//            System.out.println(le.getShippable());
//            le = le.getNextElement();   // das ist das Stoppelement
//        }
//        return le.getShippable();
       
        le.getShippable();
       
       
    }
/**
* Returns the current size of queue
*/
    @Override
    public int size() { // Ist das Richtig ? wenn nein bitte Tipps geben
        size = 0;
        QueueElement le = firstElement;
       
        while( le != null) {
            size++;
            le.getNextElement();
        }
        return size;
       
    }

   
}

Danke nochmals für die Ausführliche Antworten.

Lg
Louis

 

[MoxxiManagarm]

Bitte entferne super() aus dem QueueElement Konstruktor und sämtliche TODO Kommentare aus der Klasse. QueueElement sieht schonmal ganz gut aus.

Zur Queue: Hier scheinst du die größten Probleme noch mit enqueue zu haben, also dem Hinzufügen. Nehmen wir wieder die Verbildlichung. Du hast einen Bahnarbeiter, der bekommt die Aufgabe den Container (Shippable) in den Güterzug zu bringen. Dann musst du zuerst den Container auf einen Waggon (QueueElement) bringen. Dieses QueueElement musst du dann nur noch in den Zug reinhängen. Das zuvor letzte QueueElement hat anschließend ein next und der Zug hat ein neues letztes Element. Der hinzugefügte Waggon hat entsprechend dann auch ein previous. Sonderfall wäre das Hinzufügen in einen leeren Zug, welcher zu betrachten ist.

 

[Louis12]

Hallo ,

Bitte entferne super() aus dem QueueElement Konstruktor und sämtliche TODO Kommentare aus der Klasse. QueueElement sieht schonmal ganz gut aus.

Super das habe ich erstrmal gemacht.

Leider fällt mir enqueue wirklich schwer, ich habe es zumindest so versucht :/

 Shippable  lastElem = getLast();
        lastElem.setNextElement(shippable);

         if(shippable == null) {
             lastElem = null;
         }
               
        lastElement.setPreviousElement(lastElem);
    
    
    
       
        size++;

und einmal mit diesen Ansatz

QueueElement found = new QueueElement ( firstElement, lastElement, shippable);
        if(shippable == null) {
            firstElement = found;
        }else {
            lastElement.setNextElement(found);
            lastElement.setPreviousElement(found);
        }
        lastElement = found;

Ich denke das beide nicht stimmen könntest du mir bitte weitere Tipps geben.


Lg
louis

 

[mihe7]

Die Queue besteht nur aus QueueElement-Objekten. Jedes QueueElement kann genau ein Shippable aufnehmen. Wenn Du ein Shippable in die Queue einfügen willst, musst Du folglich erst einmal ein QueueElement erzeugen (in Moxxi-Speech: Du musst den Container auf den Waggon bringen).

Und dieses QueueElement hängst Du an das letzte Element der Queue an (der neue Waggon wird an den letzten angehängt). Das funktioniert, in dem Du die Waggons gegenseitig ankuppelst.

Dein erster Ansatz ist gar nicht mal so verkehrt. Du musst halt QueueElement-Objekte mit einbauen. Was sollen die Zeilen

         if(shippable == null) {
             lastElem = null;
         }

bewirken?

 

[MoxxiManagarm]

und einmal mit diesen Ansatz

Code (Text):
QueueElement found = new QueueElement ( firstElement, lastElement, shippable);
if(shippable == null) {
firstElement = found;
}else {
lastElement.setNextElement(found);
lastElement.setPreviousElement(found);
}
lastElement = found;

Ich finde den 2. Ansatz garnicht so verkehrt. Er hat nur die falschen Felder, 5 in der Zahl. Gleicher Code mit korrigierten Feldern und hoffentlich verständlichen Kommentaren:

// dein neues Element ist noch nicht eingehangen - Change 1 + 2
QueueElement found = new QueueElement ( null, null, shippable);

        // leere Liste - Change 3
        if(firstElement == null) {
            // Vorwärtskupplung vorne
            firstElement = found;
            // Rückwärtskupplung vorne verbleibt null
        } else {
            // Vorwärtskupplung vorne
            lastElement.setNextElement(found);
            // Rückwärtskupplung vorne, Change 4+5
            found.setPreviousElement(lastElement);
        }
      
        // Rückwärtskupplung hinten
        lastElement = found;
        // Vorwärtskupplung hinten verbleibt null

 

[Louis12]

Vielen Dank für die Antworten!!

, Ich habe auch schon mal Aufgabe 8.3 Angefangen und wollte fragen
was genau damit gemeint ist . Der Satz ist makiert und unterstrichen. Ist damit gemeint, das ich die vorherige verkettete liste hier rein kopieren soll und dann Priority irgendwie hinzufügen soll.
Ich wäre einer Antwort weiterhin sehr dankbar.

Erstellen Sie im Package de.tuberlin.mcc.prog1.logistics.store eine Klasse ShippableStore, welche das Interface IShippableStore (ebenfalls im Package) implementiert.

Fügen Sie anschließend der Klasse die Instanzvariablen express, morning, evening und standard (alle vom Typ ShippableQueue) hinzu.

Realisieren Sie in dieser Klasse eine Datenstruktur, die neue Lieferungen zum Store hinzufügt, indem sie diese entsprechend ihrer Priorität an die entsprechende Liste anfügt.

Implementieren Sie die geforderten Methoden entsprechend der gegebenen Spezifikationen in der Javadoc-Kommentierung der Schnittstelle IShippableStore.

 

[mihe7]

Ist damit gemeint, das ich die vorherige verkettete liste hier rein kopieren soll und dann Priority irgendwie hinzufügen soll.

Nein. Du sollst Deine vorherige Liste als Typ für die Instanzvariablen express, morning, evening und standard verwenden.

Meine Vermutung bzgl. des unterstrichenen Satzes ist, dass entweder Shippable selbst eine Priorität enthält, oder die add-Methode in IShippableStore eine Priorität erwartet. In jedem Fall sollst Du das übergebene Shippable entsprechend der Priorität in eine der Listen express, morning, evening und standard einfügen. Schau Dir mal Shippable und IShippableStore an, dann sollte eigentlich alles klar sein.