Initial commit

Queue.java

@@ -0,0 +1,43 @@
+
+public class Queue<ContentType> {
+
+    private QueueNode<ContentType> head = null;
+
+    private QueueNode<ContentType> tail = null;
+
+    public Queue() {
+    }
+
+    public void enqueue( ContentType pContentObject ) {
+        // TODO: Implementiere enqueue
+    }
+
+    public void dequeue() {
+        // TODO: Implementiere dequeue
+    }
+
+    /**
+     * Liefert das Inhaltsobjekt vom ersten Knotens der Schlange
+     * vom Typ ContentType, falls die Schlange nicht leer ist,
+     * ansonsten null.
+     *
+     * @return Das Inhaltsobjekt oder null.
+     */
+    public ContentType front() {
+        if( !isEmpty() ) {
+            return head.getContent();
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * Prüft, ob die Schlange leer ist.
+     *
+     * @return true, wenn die Schlange keine Knoten enthaelt
+     */
+    public boolean isEmpty() {
+        return (head == null);
+    }
+
+}

QueueNode.java

@@ -0,0 +1,47 @@
+
+public class QueueNode<ContentType> {
+
+    private ContentType contentObject = null;
+
+    private QueueNode nextNode = null;
+
+    /**
+     * Ein neues Objekt vom Typ Node<ContentType> wird erschaffen.
+     * Der Inhalt wird per Parameter gesetzt. Der Verweis ist leer.
+     *
+     * @param pContentObject das Inhaltselement des Knotens vom Typ ContentType
+     */
+    public QueueNode(ContentType pContentObject) {
+        contentObject = pContentObject;
+        nextNode = null;
+    }
+
+    /**
+     * Der Verweis wird auf das Objekt, das als Parameter uebergeben wird,
+     * gesetzt.
+     *
+     * @param pNext der Nachfolger des Knotens
+     */
+    public void setNext(QueueNode pNext) {
+        nextNode = pNext;
+    }
+
+    /**
+     * Liefert das naechste Element des aktuellen Knotens.
+     *
+     * @return das Objekt vom Typ QueueNode, auf das der aktuelle Verweis zeigt
+     */
+    public QueueNode getNext() {
+        return nextNode;
+    }
+
+    /**
+     * Liefert das Inhaltsobjekt des Knotens vom Typ ContentType.
+     *
+     * @return das Inhaltsobjekt des Knotens
+     */
+    public ContentType getContent() {
+        return contentObject;
+    }
+
+}

QueueTest.java

@@ -0,0 +1,99 @@
+
+
+import static org.junit.Assert.*;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+public class QueueTest
+{
+
+    @Test
+    public void testeEnqueue() {
+        Queue<String> schlange = new Queue<>();
+
+        schlange.enqueue("Hallo, ");
+
+        assertEquals("Nach einmal enqueue darf die Schlange nicht leer sein.",
+            false, schlange.isEmpty()); // erwartet: false
+        assertEquals("Nach dem FIFO-Prinzip muss front 'Hallo, ' sein",
+            "Hallo, ", schlange.front()); // erwartet: Hallo,
+
+        schlange.enqueue("Welt!");
+
+        assertEquals("Nach nocheinmal enqueue darf die Schlange weiter nicht leer sein.",
+            false, schlange.isEmpty()); // erwartet: false
+        assertEquals("Nach dem FIFO-Prinzip muss front weiter 'Hallo, ' sein",
+            "Hallo, ", schlange.front()); // erwartet: Hallo,
+    }
+
+
+    @Test
+    public void testeDequeue() {
+        Queue<String> schlange = new Queue<String>();
+
+        schlange.enqueue("Hallo, ");
+        schlange.enqueue("Welt!");
+
+        schlange.dequeue();
+        assertEquals("Nach zweimal enqueue und einmal dequeue darf die Schlange noch nicht leer sein.",
+            false, schlange.isEmpty()); // erwartet: false
+        assertEquals("Top muss nun 'Welt!' sein.",
+            "Welt!", schlange.front()); // erwartet: Welt!
+
+        schlange.dequeue();
+        assertEquals("Nach zweimal dequeue muss die Schlange leer sein.",
+            true, schlange.isEmpty()); // erwartet: true
+        assertNull("Es gibt kein erstes Element mehr,",
+            schlange.front()); // erwartet: null
+    }
+
+
+    @Test
+    public void testeFront() {
+        Queue<Integer> schlange = new Queue<>();
+
+        assertNull("Front einer leeren Schlange ist null.",
+            schlange.front()); // erwartet: null
+
+        // Ab hier benoetigen die Tests funktionierende enqueue und dequeue Operationen
+        schlange.enqueue(99);
+        assertEquals("Front nach einmal enqueue muss das einzige Element sein.",
+            new Integer(99), schlange.front()); // erwartet: 99
+
+        schlange.enqueue(88);
+        schlange.enqueue(77);
+        assertEquals("Nach mehrmals enqueue muss front weiter das erste Element sein.",
+            new Integer(99), schlange.front()); // erwartet: 99
+
+        schlange.dequeue();
+        assertEquals("Nach dequeue muss front das zweite Element sein.",
+            new Integer(88), schlange.front()); // erwartet: 88
+    }
+
+
+
+    @Test
+    public void testeIsEmpty() {
+        Queue<String> schlange = new Queue<String>();
+
+        assertEquals("Eine neue Schlange muss leer sein.",
+            true, schlange.isEmpty()); // erwartet: true
+
+        // Ab hier benoetigen die Tests funktionierende enqueue und dequeue Operationen
+        schlange.enqueue("Hallo, ");
+        assertEquals("Nach einmal enqueue darf die Schlange nicht leer sein.",
+            false, schlange.isEmpty()); // erwartet: false
+
+        schlange.dequeue();
+        assertEquals("Nach einmal dequeue muss die Schlange wieder leer sein.",
+            true, schlange.isEmpty()); // erwartet: true
+
+        schlange.enqueue("Hallo, ");
+        schlange.enqueue("Welt!");
+        schlange.dequeue();
+        assertEquals("Nach zweimal enqueue und einmal dequeue darf die Schlange nicht leer sein.",
+            false, schlange.isEmpty()); // erwartet: false
+    }
+
+}

README.TXT

@@ -0,0 +1,4 @@
+Implementierung der enqueue- und dequeue-Operationen in der Queue-Klasse
+(Schlange) aus dem Zentralabitur NRW.
+
+Version: 2020-09-09

Stack.java

@@ -0,0 +1,45 @@
+
+public class Stack<ContentType> {
+
+    private StackNode<ContentType> head = null;
+
+    public Stack() {
+    }
+
+
+    public void push( ContentType pContentObject ) {
+        // TODO: Implementiere push
+    }
+
+    public void pop() {
+        // TODO: Implementiere pop
+        if( head != null ) {
+            head = head.getNext();
+        }
+    }
+
+    /**
+     * Liefert das Inhaltsobjekt vom obersten Knoten des Stapels
+     * vom Typ ContentType, falls die Schlange nicht leer ist,
+     * ansonsten null.
+     *
+     * @return Das Inhaltsobjekt oder null.
+     */
+    public ContentType top() {
+        if( !isEmpty() ) {
+            return head.getContent();
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * Prüft, ob der Stapel leer ist.
+     *
+     * @return true, wenn der Stapel keine Knoten enthaelt
+     */
+    public boolean isEmpty() {
+        return (head == null);
+    }
+
+}

StackNode.java

@@ -0,0 +1,47 @@
+
+public class StackNode<ContentType> {
+
+    private ContentType contentObject = null;
+
+    private StackNode nextNode = null;
+
+    /**
+     * Ein neues Objekt vom Typ Node<ContentType> wird erschaffen.
+     * Der Inhalt wird per Parameter gesetzt. Der Verweis ist leer.
+     *
+     * @param pContentObject das Inhaltselement des Knotens vom Typ ContentType
+     */
+    public StackNode( ContentType pContentObject) {
+        contentObject = pContentObject;
+        nextNode = null;
+    }
+
+    /**
+     * Der Verweis wird auf das Objekt, das als Parameter uebergeben wird,
+     * gesetzt.
+     *
+     * @param pNext der Nachfolger des Knotens
+     */
+    public void setNext( StackNode pNext) {
+        nextNode = pNext;
+    }
+
+    /**
+     * Liefert das naechste Element des aktuellen Knotens.
+     *
+     * @return das Objekt vom Typ QueueNode, auf das der aktuelle Verweis zeigt
+     */
+    public StackNode getNext() {
+        return nextNode;
+    }
+
+    /**
+     * Liefert das Inhaltsobjekt des Knotens vom Typ ContentType.
+     *
+     * @return das Inhaltsobjekt des Knotens
+     */
+    public ContentType getContent() {
+        return contentObject;
+    }
+
+}

StackTest.java

@@ -0,0 +1,95 @@
+
+
+import static org.junit.Assert.*;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+public class StackTest
+{
+
+    @Test
+    public void testePush() {
+        Stack<String> stapel = new Stack<String>();
+
+        stapel.push("Hallo, ");
+
+        assertEquals("Nach einmal push darf der Stapel nicht leer sein.",
+            false, stapel.isEmpty()); // erwartet: false
+        assertEquals("Nach dem LIFO-Prinzip muss top 'Hallo, ' sein",
+            "Hallo, ", stapel.top()); // erwartet: Hallo,
+
+        stapel.push("Welt!");
+
+        assertEquals("Nach nocheinmal push darf der Stapel weiter nicht leer sein.",
+            false, stapel.isEmpty()); // erwartet: false
+        assertEquals("Nach dem LIFO-Prinzip muss top nun 'Welt!' sein",
+            "Welt!", stapel.top()); // erwartet: Welt!
+    }
+
+
+    @Test
+    public void testePop() {
+        Stack<String> stapel = new Stack<String>();
+
+        stapel.push("Hallo, ");
+        stapel.push("Welt!");
+
+        stapel.pop();
+        assertEquals("Nach zweimal push und einmal pop darf der Stapel noch nicht leer sein.",
+            false, stapel.isEmpty()); // erwartet: false
+        assertEquals("Top muss nun 'Hallo, ' sein.",
+            "Hallo, ", stapel.top()); // erwartet: Hallo,
+
+        stapel.pop();
+        assertEquals("Nach zweimal pop muss der Stapel leer sein.",
+            true, stapel.isEmpty()); // erwartet: true
+        assertNull("Es gibt kein erstes Element mehr,",
+            stapel.top()); // erwartet: null
+    }
+
+
+    @Test
+    public void testeTop() {
+        Stack<Integer> stapel = new Stack<Integer>();
+
+        assertNull("Top eines leeren Stapels ist null.",
+            stapel.top()); // erwartet: null
+
+        // Die folgenden Tests benötigen funktionierende push und pop Operationen
+        stapel.push(99);
+        assertEquals("Top nach einmal push muss das einzige Element sein.",
+            new Integer(99), stapel.top()); // erwartet: 99
+
+        stapel.push(99);
+        stapel.push(88);
+        stapel.push(77);
+        assertEquals("Nach mehrmals push muss top das letzt Element sein.",
+            new Integer(77), stapel.top()); // erwartet: 77
+    }
+
+
+
+    @Test
+    public void testeIsEmpty() {
+        Stack<String> stapel = new Stack<String>();
+
+        assertEquals("Ein neuer Stapel muss leer sein.",
+            true, stapel.isEmpty()); // erwartet: true
+
+        // Die folgenden Tests benötigen funktionierende push und pop Operationen
+        stapel.push("Hallo, ");
+        assertEquals("Nach einmal push darf der Stapel nicht leer sein.",
+            false, stapel.isEmpty()); // erwartet: false
+
+        stapel.pop();
+        assertEquals("Nach einmal pop muss der Stapel wieder leer sein.",
+            true, stapel.isEmpty()); // erwartet: true
+
+        stapel.push("Hallo, ");
+        stapel.push("Welt!");
+        stapel.pop();
+        assertEquals("Nach zweimal push und einmal pop darf der Stapel nicht leer sein.",
+            false, stapel.isEmpty()); // erwartet: false
+    }
+}

package.bluej

@@ -0,0 +1,79 @@
+#BlueJ package file
+dependency1.from=QueueTest
+dependency1.to=Queue
+dependency1.type=UsesDependency
+dependency2.from=StackTest
+dependency2.to=Stack
+dependency2.type=UsesDependency
+dependency3.from=Queue
+dependency3.to=QueueNode
+dependency3.type=UsesDependency
+dependency4.from=Stack
+dependency4.to=StackNode
+dependency4.type=UsesDependency
+editor.fx.0.height=0
+editor.fx.0.width=0
+editor.fx.0.x=0
+editor.fx.0.y=0
+objectbench.height=114
+objectbench.width=907
+package.divider.horizontal=0.6
+package.divider.vertical=0.7787934186471663
+package.editor.height=419
+package.editor.width=793
+package.editor.x=37
+package.editor.y=23
+package.frame.height=605
+package.frame.width=931
+package.numDependencies=4
+package.numTargets=6
+package.showExtends=true
+package.showUses=true
+project.charset=UTF-8
+readme.height=58
+readme.name=@README
+readme.width=47
+readme.x=10
+readme.y=10
+target1.height=50
+target1.name=QueueNode
+target1.showInterface=false
+target1.type=ClassTarget
+target1.width=200
+target1.x=160
+target1.y=60
+target2.height=50
+target2.name=QueueTest
+target2.showInterface=false
+target2.type=UnitTestTargetJunit4
+target2.width=90
+target2.x=250
+target2.y=160
+target3.height=50
+target3.name=StackNode
+target3.showInterface=false
+target3.type=ClassTarget
+target3.width=180
+target3.x=520
+target3.y=60
+target4.height=50
+target4.name=StackTest
+target4.showInterface=false
+target4.type=UnitTestTargetJunit4
+target4.width=80
+target4.x=600
+target4.y=170
+target5.height=50
+target5.name=Queue
+target5.showInterface=false
+target5.type=ClassTarget
+target5.width=160
+target5.x=50
+target5.y=230
+target6.height=50
+target6.name=Stack
+target6.showInterface=false
+target6.type=ClassTarget
+target6.width=150
+target6.x=410
+target6.y=230