From 74bc7fce512a9cf5af83bf47b0667fe572187952 Mon Sep 17 00:00:00 2001 From: Jonas Neugebauer Date: Wed, 9 Sep 2020 22:37:01 +0200 Subject: [PATCH] Initial commit --- Queue.java | 43 ++++++++++++++++++++++ QueueNode.java | 47 ++++++++++++++++++++++++ QueueTest.java | 99 ++++++++++++++++++++++++++++++++++++++++++++++++++ README.TXT | 4 ++ Stack.java | 45 +++++++++++++++++++++++ StackNode.java | 47 ++++++++++++++++++++++++ StackTest.java | 95 ++++++++++++++++++++++++++++++++++++++++++++++++ package.bluej | 79 ++++++++++++++++++++++++++++++++++++++++ 8 files changed, 459 insertions(+) create mode 100644 Queue.java create mode 100644 QueueNode.java create mode 100644 QueueTest.java create mode 100644 README.TXT create mode 100644 Stack.java create mode 100644 StackNode.java create mode 100644 StackTest.java create mode 100644 package.bluej diff --git a/Queue.java b/Queue.java new file mode 100644 index 0000000..9490bd6 --- /dev/null +++ b/Queue.java @@ -0,0 +1,43 @@ + +public class Queue { + + private QueueNode head = null; + + private QueueNode 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); + } + +} diff --git a/QueueNode.java b/QueueNode.java new file mode 100644 index 0000000..9edaed6 --- /dev/null +++ b/QueueNode.java @@ -0,0 +1,47 @@ + +public class QueueNode { + + private ContentType contentObject = null; + + private QueueNode nextNode = null; + + /** + * Ein neues Objekt vom Typ Node 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; + } + +} diff --git a/QueueTest.java b/QueueTest.java new file mode 100644 index 0000000..8f818fc --- /dev/null +++ b/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 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 schlange = new Queue(); + + 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 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 schlange = new Queue(); + + 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 + } + +} diff --git a/README.TXT b/README.TXT new file mode 100644 index 0000000..e2c297d --- /dev/null +++ b/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 diff --git a/Stack.java b/Stack.java new file mode 100644 index 0000000..ac03d33 --- /dev/null +++ b/Stack.java @@ -0,0 +1,45 @@ + +public class Stack { + + private StackNode 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); + } + +} diff --git a/StackNode.java b/StackNode.java new file mode 100644 index 0000000..dc4fe75 --- /dev/null +++ b/StackNode.java @@ -0,0 +1,47 @@ + +public class StackNode { + + private ContentType contentObject = null; + + private StackNode nextNode = null; + + /** + * Ein neues Objekt vom Typ Node 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; + } + +} diff --git a/StackTest.java b/StackTest.java new file mode 100644 index 0000000..242c876 --- /dev/null +++ b/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 stapel = new Stack(); + + 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 stapel = new Stack(); + + 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 stapel = new Stack(); + + 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 stapel = new Stack(); + + 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 + } +} diff --git a/package.bluej b/package.bluej new file mode 100644 index 0000000..4b2b954 --- /dev/null +++ b/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