SHARE
TWEET

Untitled

a guest May 24th, 2019 69 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. package einkaufskasse;
  2.  
  3. /**
  4.  * <p>
  5.  * Materialien zu den zentralen NRW-Abiturpruefungen im Fach Informatik ab 2018
  6.  * </p>
  7.  * <p>
  8.  * Generische Klasse Queue<ContentType>
  9.  * </p>
  10.  * <p>
  11.  * Objekte der generischen Klasse Queue (Warteschlange) verwalten beliebige
  12.  * Objekte vom Typ ContentType nach dem First-In-First-Out-Prinzip, d.h., das
  13.  * zuerst abgelegte Objekt wird als erstes wieder entnommen. Alle Methoden haben
  14.  * eine konstante Laufzeit, unabhaengig von der Anzahl der verwalteten Objekte.
  15.  * </p>
  16.  *
  17.  * @author Qualitaets- und UnterstuetzungsAgentur - Landesinstitut fuer Schule
  18.  * @version Generisch_02 2014-02-21
  19.  */
  20. public class Queue<ContentType> {
  21.    
  22.     /* --------- Anfang der privaten inneren Klasse -------------- */
  23.    
  24.     private class QueueNode {
  25.  
  26.         private ContentType content = null;
  27.         private QueueNode nextNode = null;
  28.  
  29.         /**
  30.          * Ein neues Objekt vom Typ QueueNode<ContentType> wird erschaffen.
  31.          * Der Inhalt wird per Parameter gesetzt. Der Verweis ist leer.
  32.          *
  33.          * @param pContent das Inhaltselement des Knotens vom Typ ContentType
  34.          */
  35.         public QueueNode(ContentType pContent) {
  36.             content = pContent;
  37.             nextNode = null;
  38.         }
  39.  
  40.         /**
  41.          * Der Verweis wird auf das Objekt, das als Parameter uebergeben wird,
  42.          * gesetzt.
  43.          *
  44.          * @param pNext der Nachfolger des Knotens
  45.          */
  46.         public void setNext(QueueNode pNext) {
  47.             nextNode = pNext;
  48.         }
  49.        
  50.         /**
  51.          * Liefert das naechste Element des aktuellen Knotens.
  52.          *
  53.          * @return das Objekt vom Typ QueueNode, auf das der aktuelle Verweis zeigt
  54.          */
  55.         public QueueNode getNext() {
  56.             return nextNode;
  57.         }
  58.  
  59.         /**
  60.          * Liefert das Inhaltsobjekt des Knotens vom Typ ContentType.
  61.          *
  62.          * @return das Inhaltsobjekt des Knotens
  63.          */
  64.         public ContentType getContent() {
  65.             return content;
  66.         }
  67.        
  68.     }
  69.    
  70.     /* ----------- Ende der privaten inneren Klasse -------------- */
  71.    
  72.     private QueueNode head;
  73.     private QueueNode tail;
  74.  
  75.     /**
  76.      * Eine leere Schlange wird erzeugt.
  77.      * Objekte, die in dieser Schlange verwaltet werden, muessen vom Typ
  78.      * ContentType sein.
  79.      */
  80.     public Queue() {
  81.         head = null;
  82.         tail = null;
  83.     }
  84.  
  85.     /**
  86.      * Die Anfrage liefert den Wert true, wenn die Schlange keine Objekte enthaelt,
  87.      * sonst liefert sie den Wert false.
  88.      *
  89.      * @return true, falls die Schlange leer ist, sonst false
  90.      */
  91.     public boolean isEmpty() {
  92.         return head == null;
  93.     }
  94.  
  95.     /**
  96.      * Das Objekt pContentType wird an die Schlange angehaengt.
  97.      * Falls pContentType gleich null ist, bleibt die Schlange unveraendert.
  98.      *
  99.      * @param pContent
  100.      *            das anzuhaengende Objekt vom Typ ContentType
  101.      */
  102.     public void enqueue(ContentType pContent) {
  103.         if (pContent != null) {
  104.             QueueNode newNode = new QueueNode(pContent);
  105.             if (this.isEmpty()) {
  106.                 head = newNode;
  107.                 tail = newNode;
  108.             } else {
  109.                 tail.setNext(newNode);
  110.                 tail = newNode;
  111.             }
  112.         }
  113.     }
  114.  
  115.     /**
  116.      * Das erste Objekt wird aus der Schlange entfernt.
  117.      * Falls die Schlange leer ist, wird sie nicht veraendert.
  118.      */
  119.     public void dequeue() {
  120.         if (!this.isEmpty()) {
  121.             head = head.getNext();
  122.             if (this.isEmpty()) {
  123.                 head = null;
  124.                 tail = null;
  125.             }
  126.         }
  127.     }
  128.  
  129.     /**
  130.      * Die Anfrage liefert das erste Objekt der Schlange.
  131.      * Die Schlange bleibt unveraendert.
  132.      * Falls die Schlange leer ist, wird null zurueckgegeben.
  133.      *
  134.      * @return das erste Objekt der Schlange vom Typ ContentType oder null,
  135.      *         falls die Schlange leer ist
  136.      */
  137.     public ContentType front() {
  138.         if (this.isEmpty()) {
  139.             return null;
  140.         } else {
  141.             return head.getContent();
  142.         }
  143.     }
  144.    
  145.    
  146. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!
 
Top