Datenstrukturen/ Listen

Louis12

Aktives Mitglied
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

Top Contributor
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

Top Contributor
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

Aktives Mitglied
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?.

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;
 
 
 
 
 
 

    @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() ;
    }

 
}
 

Louis12

Aktives Mitglied
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.

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.
Code:
/**
* 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?
Code:
/**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.

Code:
/**
* 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

Top Contributor
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

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

Java:
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

Aktives Mitglied
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.

Code:
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.
Code:
if (firstElement == null) lastElement = null; coden muss


Hier habe ich es selber versucht anzuwenden
Code:
@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

Top Contributor
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:
Code:
       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:
Code:
       next        next          next
[Hans] ---> [Inge] --->  [Franz] ---> []
  ^           ^
  |           |
 result      first
Abschließend entfernt man noch vom Ergebnis die Nachfolge-Referenz (von Hans auf Inge):

Code:
       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:
Code:
          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:
Code:
           next
   [Franz] ---> []
    ^   ^        ^
    |   |        |
result last    first
Wie unschwer zu erkennen ist, stimmt die last-Referenz nicht. Die muss ebenfalls auf null gesetzt werden:
Code:
           next
   [Franz] ---> []
    ^            ^
    |            |
result      first/last
Und genau deshalb, steht dort:
Java:
firstElement = firstElement.getNextElement();
if (firstElement == null) lastElement = null;
Ich hoffe, dass jetzt einiges klarer geworden ist.
 

Louis12

Aktives Mitglied
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.

Code:
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.

}

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) {
       
        //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

Aktives Mitglied
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.

Code:
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.

}

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) {
       
        //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

Top Contributor
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

Aktives Mitglied
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 :/
Code:
 Shippable  lastElem = getLast();
        lastElem.setNextElement(shippable);

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

und einmal mit diesen Ansatz

Code:
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

Top Contributor
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
Java:
         if(shippable == null) {
             lastElem = null;
         }
bewirken?
 

MoxxiManagarm

Top Contributor
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:

Java:
// 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
 
Zuletzt bearbeitet:

Louis12

Aktives Mitglied
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

Top Contributor
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.
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
K Algorithmen und Datenstrukturen Programmier Aufgabe Java Basics - Anfänger-Themen 10
V_Fynn03 Beliebiges Element in einer Liste löschen (Java)(Lineare Datenstrukturen) Java Basics - Anfänger-Themen 9
V_Fynn03 Lineare Datenstrukturen Element löschen? Java Basics - Anfänger-Themen 2
F Datenstrukturen Java Basics - Anfänger-Themen 5
S Datenstrukturen Java Basics - Anfänger-Themen 7
J Dynamische Datenstrukturen Java Basics - Anfänger-Themen 0
B Datenstrukturen in Java Java Basics - Anfänger-Themen 6
D komplexe Datenstrukturen "klonen" Java Basics - Anfänger-Themen 4
M Algorithmen und Datenstrukturen Java Basics - Anfänger-Themen 3
W Übungsaufgabe:Dynamische Datenstrukturen Java Basics - Anfänger-Themen 10
K Datentypen Gleiche Zufallszahlen in verschiedenen Datenstrukturen Java Basics - Anfänger-Themen 6
G Unterschied zwischen den Datenstrukturen Java Basics - Anfänger-Themen 2
G Probleme mit Datenstrukturen (Vektor, HashMap) Java Basics - Anfänger-Themen 5
H generische Bausteine, heterogene Datenstrukturen Java Basics - Anfänger-Themen 2
J Datenstrukturen Java Basics - Anfänger-Themen 12
S Datenstrukturen Java Basics - Anfänger-Themen 7
B Datenstrukturen & Algorithmen => Iteratoren Java Basics - Anfänger-Themen 7
D Listen in Listen in Listen ... ??? Java Basics - Anfänger-Themen 2
XWing listen Java Basics - Anfänger-Themen 7
FunkyPhil94 addLast und addFirst bei Listen Java Basics - Anfänger-Themen 6
S Einfach-Verkettete-Listen Ausgabe zeigt nur 1. und letzte instanz Java Basics - Anfänger-Themen 2
J 2 listen vergleichen, die auch null Elemente haben können ! Java Basics - Anfänger-Themen 9
W Liste mit Listen in JTable darstellen Java Basics - Anfänger-Themen 1
Buroto Threads Verschiedene .txt Dateien Auf Listen und Verbinden Java Basics - Anfänger-Themen 3
M Generics Vererbung Listen Java Basics - Anfänger-Themen 2
T Collections Sind Subklassen-Objekte in Listen mit Generics erlaubt? Java Basics - Anfänger-Themen 16
S Lineare listen verkettung Java Basics - Anfänger-Themen 7
S Listen Java Basics - Anfänger-Themen 12
S Listen , Nodes am ende anängen Java Basics - Anfänger-Themen 6
P Sortieren von Listen nach Attributen Java Basics - Anfänger-Themen 3
M Java Listen Java Basics - Anfänger-Themen 4
V einfach verkettete Listen Java Basics - Anfänger-Themen 10
A PhoneBook mit verketteten listen Java Basics - Anfänger-Themen 48
F ich brauche Hilfe bei Listen Java Basics - Anfänger-Themen 13
M (Sehr großes Problem) Listen als static in anderen Klassen verwendet Java Basics - Anfänger-Themen 12
G Java Listen und Iterator Java Basics - Anfänger-Themen 2
S Erklaerung Listen Java Basics - Anfänger-Themen 27
J Implementierung Listen-ADT Java Basics - Anfänger-Themen 131
I Alle Elemente von zwei Listen vergleichen Java Basics - Anfänger-Themen 1
L Skip Listen Java Basics - Anfänger-Themen 5
S Collections funktionale Listen (ListNode<E>) review und problem beim clone Java Basics - Anfänger-Themen 0
L Wie testet man (selbstgeschriebene) Listen sinnvoll? Java Basics - Anfänger-Themen 2
F Problem mit Listen Java Basics - Anfänger-Themen 5
J Listen Operationen Java Basics - Anfänger-Themen 4
O Unterschied Arrays, Listen, Mengen Java Basics - Anfänger-Themen 24
J Eine Liste von Listen erstellen Java Basics - Anfänger-Themen 11
A Sortierte Listen Java Basics - Anfänger-Themen 4
A Was könnten typische Prüfungsaufgaben zum Thema lineare, verkettete Listen sein? Java Basics - Anfänger-Themen 5
L Listen und Felder Java Basics - Anfänger-Themen 2
M Fragen zum Anlegen und Benutzen von Listen Java Basics - Anfänger-Themen 9
R Arrays und Listen Java Basics - Anfänger-Themen 1
R Listen richtig implementieren Java Basics - Anfänger-Themen 3
F Multidimensionale Listen Java Basics - Anfänger-Themen 3
F Wie String in unterschiedliche Listen teilen Java Basics - Anfänger-Themen 7
R Interface Eigene Objekte in Listen sortieren mit Interface Comparable Java Basics - Anfänger-Themen 5
T Objekte in Listen vererben Java Basics - Anfänger-Themen 3
A Klassen Klassen und Listen... Java Basics - Anfänger-Themen 5
Hacer Operationen einfach verketteter Listen Java Basics - Anfänger-Themen 22
S Methoden Vergleichen von zwei Listen in der Geschwindigkeit von O(n+m) Java Basics - Anfänger-Themen 32
P Listen sortieren mit Binärbaum gibt keine Ausgabe ab 10000 Integern Java Basics - Anfänger-Themen 14
C Listen Java Basics - Anfänger-Themen 3
C Zwei Listen verbinden Java Basics - Anfänger-Themen 1
C Zahlen merken mit Hilfe von Arrays/Listen Java Basics - Anfänger-Themen 2
E Feld von verketteten Listen Java Basics - Anfänger-Themen 11
T Überprüfung einer Aufgabe zu verketteten Listen Java Basics - Anfänger-Themen 5
S Liste mit Objekten und Listen Java Basics - Anfänger-Themen 9
JarJarBigs Frage zu Listen Java Basics - Anfänger-Themen 2
N verkettete Listen Java Basics - Anfänger-Themen 4
O Listen sort-Methode Java Basics - Anfänger-Themen 1
I Listen sortieren bei mehreren Listen zu einer Java Basics - Anfänger-Themen 2
L Lineare Listen Java Basics - Anfänger-Themen 2
S Listen Objekte nach LocalDateTime sortieren Java Basics - Anfänger-Themen 2
D Methoden Listen generieren Java Basics - Anfänger-Themen 4
A Sichtbarkeit in Methoden/Listen Java Basics - Anfänger-Themen 3
M verkettete Listen Java Basics - Anfänger-Themen 1
D Klausur Vorbereitung: Listen, Rekursion, Bäume & Vererbung Java Basics - Anfänger-Themen 3
S Vergleich von Listen Java Basics - Anfänger-Themen 6
I Zwei Listen vergleichen Java Basics - Anfänger-Themen 2
M Listen erstellen mit unterschiedlichen Reihenfolgen Java Basics - Anfänger-Themen 3
I Zwei Listen vergleichen bei n:m Beziehung Java Basics - Anfänger-Themen 2
I Zwei Listen: Wenn nicht vorhanden löschen Java Basics - Anfänger-Themen 4
I Prüfen von zwei Listen Java Basics - Anfänger-Themen 1
K Interface Generics, Interfaces und Listen - ich bin verwirrt. Java Basics - Anfänger-Themen 7
L Best Practice Alle Kombinationen aus Listenelementen, Anzahl Listen unterschiedlich Java Basics - Anfänger-Themen 6
llabusch Verkette Listen - Einfach und Doppelt Java Basics - Anfänger-Themen 3
S Unsortierte Listen - Frage zur "Verkettung" Java Basics - Anfänger-Themen 1
I Zwei Listen vergleichen Java Basics - Anfänger-Themen 7
I Listen, for - Schleifen Java Basics - Anfänger-Themen 8
P Listen Size stimmt nicht Java Basics - Anfänger-Themen 5
O Objekt Listen serialisierung und deserialisieren Java Basics - Anfänger-Themen 5
L Collections Objekte in Listen speichern Java Basics - Anfänger-Themen 3
G 2 Listen kombinieren und nach abc sortieren Java Basics - Anfänger-Themen 9
D Annonyme Innere Klasse: Listen mit geradem Index ausgeben Java Basics - Anfänger-Themen 6
G Listen sortieren Java Basics - Anfänger-Themen 3
G Generic und Listen Java Basics - Anfänger-Themen 8
R SQL ähnlicher Filter für Java Listen Java Basics - Anfänger-Themen 2
Y Collections 4 Listen Java Basics - Anfänger-Themen 14
S OOP/ Listen...etc... Java Basics - Anfänger-Themen 14
E Listen Java Basics - Anfänger-Themen 2
V Methoden Verkettete Listen Index eines Elementes ausgeben Java Basics - Anfänger-Themen 10

Ähnliche Java Themen

Neue Themen


Oben