From 86db7da2be1bf565c0b945b96760cce9c9b0c34a Mon Sep 17 00:00:00 2001
From: Jonas Neugebauer <jonas@neugebauer.cc>
Date: Sun, 13 Sep 2020 15:16:43 +0200
Subject: [PATCH] Initial commit

---
 .gitignore          |  26 ++++++++
 CheeseChampion.java |  57 ++++++++++++++++++
 Maus.java           |   9 +++
 Queue.java          | 142 ++++++++++++++++++++++++++++++++++++++++++++
 README.TXT          |   4 ++
 Stack.java          | 126 +++++++++++++++++++++++++++++++++++++++
 package.bluej       |  52 ++++++++++++++++
 7 files changed, 416 insertions(+)
 create mode 100644 .gitignore
 create mode 100644 CheeseChampion.java
 create mode 100644 Maus.java
 create mode 100644 Queue.java
 create mode 100644 README.TXT
 create mode 100644 Stack.java
 create mode 100644 package.bluej

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..9fe8940
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,26 @@
+# ---> Java
+# Compiled class file
+*.class
+
+# Log file
+*.log
+
+# BlueJ files
+*.ctxt
+Dokumente*
+
+# Mobile Tools for Java (J2ME)
+.mtj.tmp/
+
+# Package Files #
+*.jar
+*.war
+*.nar
+*.ear
+*.zip
+*.tar.gz
+*.rar
+
+# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
+hs_err_pid*
+
diff --git a/CheeseChampion.java b/CheeseChampion.java
new file mode 100644
index 0000000..9c12935
--- /dev/null
+++ b/CheeseChampion.java
@@ -0,0 +1,57 @@
+
+public class CheeseChampion {
+
+    // TODO: Ersetze ??? durch die passende Datenstruktur
+    private ??? eingang;
+    private ??? seitengang;
+    private ??? ausgang;
+
+    public CheeseChampion() {
+        // TODO: Ersetze ??? durch die passende Datenstruktur
+        eingang = ???;
+        seitengang = ???;
+        ausgang = ???;
+    }
+
+    /**
+     * Erzeugt <var>anzahl</var> fortlaufend nummerierte Mäuse (von 1 bis
+     * <var>anzahl</var>) mit zufälliger Stärke.
+     * @param anzahl
+     * @see java.util.Random
+     */
+    public void erzeugeMaeuse( int anzahl ) {
+        // TODO: Erzeuge hier "anzahl" Mäuse mit zufälliger Stärke
+    }
+
+    /**
+     * Führt den Mäusekampf nach den bekannten Regeln durch.
+     *
+     * Siehe im Buch auf Seite 88 für eine Beschreibung des Kampfes.
+     */
+    public void kampf() {
+        // TODO: Implemenitere hier den Mäusekampf
+    }
+
+    /**
+     * Erzeugt eine Startaufstellung von zehn Mäusen mit festen Stärken, mit
+     * denen der Kampf geprüft werden kann. Die erwartete Reihenfolge der Mäuse
+     * im Ausgang lautet:
+     * <pre>
+     * #2, #3, #5, #6, #4, #1, #8, #9, #10, #7
+     * </pre>
+     */
+    public void erzeugeTestMaeuse() {
+        eingang.enqueue( new Maus(1, 8) );
+        eingang.enqueue( new Maus(2, 75) );
+        eingang.enqueue( new Maus(3, 33) );
+        eingang.enqueue( new Maus(4, 23) );
+        eingang.enqueue( new Maus(5, 73) );
+        eingang.enqueue( new Maus(6, 71) );
+        eingang.enqueue( new Maus(7, 6) );
+        eingang.enqueue( new Maus(8, 86) );
+        eingang.enqueue( new Maus(9, 63) );
+        eingang.enqueue( new Maus(10, 38) );
+    }
+
+
+}
diff --git a/Maus.java b/Maus.java
new file mode 100644
index 0000000..f102c61
--- /dev/null
+++ b/Maus.java
@@ -0,0 +1,9 @@
+/**
+ * Eine Maus, die am Mäusekampf (Cheese Champion) teilnimmt, hat eine Nummer
+ * und eine Stärke als Attribute.
+ */
+public class Maus {
+
+    TODO: Implementiere die Maus nach der Beschreibung
+
+}
diff --git a/Queue.java b/Queue.java
new file mode 100644
index 0000000..e7835c0
--- /dev/null
+++ b/Queue.java
@@ -0,0 +1,142 @@
+/**
+ * <p>
+ * Materialien zu den zentralen NRW-Abiturpruefungen im Fach Informatik ab 2018
+ * </p>
+ * <p>
+ * Generische Klasse Queue<ContentType>
+ * </p>
+ * <p>
+ * Objekte der generischen Klasse Queue (Warteschlange) verwalten beliebige
+ * Objekte vom Typ ContentType nach dem First-In-First-Out-Prinzip, d.h., das
+ * zuerst abgelegte Objekt wird als erstes wieder entnommen. Alle Methoden haben
+ * eine konstante Laufzeit, unabhaengig von der Anzahl der verwalteten Objekte.
+ * </p>
+ * 
+ * @author Qualitaets- und UnterstuetzungsAgentur - Landesinstitut fuer Schule
+ * @version Generisch_02 2014-02-21
+ */
+public class Queue<ContentType> {
+	
+	/* --------- Anfang der privaten inneren Klasse -------------- */
+	
+	private class QueueNode {
+
+		private ContentType content = null;
+		private QueueNode nextNode = null;
+
+		/**
+		 * Ein neues Objekt vom Typ QueueNode<ContentType> wird erschaffen. 
+		 * Der Inhalt wird per Parameter gesetzt. Der Verweis ist leer.
+		 * 
+		 * @param pContent das Inhaltselement des Knotens vom Typ ContentType
+		 */
+		public QueueNode(ContentType pContent) {
+			content = pContent;
+			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 content;
+		}
+		
+	}
+	
+	/* ----------- Ende der privaten inneren Klasse -------------- */
+	
+	private QueueNode head;
+	private QueueNode tail;
+
+	/**
+	 * Eine leere Schlange wird erzeugt. 
+	 * Objekte, die in dieser Schlange verwaltet werden, muessen vom Typ
+	 * ContentType sein.
+	 */
+	public Queue() {
+		head = null;
+		tail = null;
+	}
+
+	/**
+	 * Die Anfrage liefert den Wert true, wenn die Schlange keine Objekte enthaelt, 
+	 * sonst liefert sie den Wert false.
+	 * 
+	 * @return true, falls die Schlange leer ist, sonst false
+	 */
+	public boolean isEmpty() {
+		return head == null;
+	}
+
+	/**
+	 * Das Objekt pContentType wird an die Schlange angehaengt. 
+	 * Falls pContentType gleich null ist, bleibt die Schlange unveraendert.
+	 * 
+	 * @param pContent
+	 *            das anzuhaengende Objekt vom Typ ContentType
+	 */
+	public void enqueue(ContentType pContent) {
+		if (pContent != null) {
+			QueueNode newNode = new QueueNode(pContent);
+			if (this.isEmpty()) {
+				head = newNode;
+				tail = newNode;
+			} else {
+				tail.setNext(newNode);
+				tail = newNode;
+			}
+		}
+	}
+
+	/**
+	 * Das erste Objekt wird aus der Schlange entfernt. 
+	 * Falls die Schlange leer ist, wird sie nicht veraendert.
+	 */
+	public void dequeue() {
+		if (!this.isEmpty()) {
+			head = head.getNext();
+			if (this.isEmpty()) {
+				head = null;
+				tail = null;
+			}
+		}
+	}
+
+	/**
+	 * Die Anfrage liefert das erste Objekt der Schlange. 
+	 * Die Schlange bleibt unveraendert. 
+	 * Falls die Schlange leer ist, wird null zurueckgegeben.
+	 *
+	 * @return das erste Objekt der Schlange vom Typ ContentType oder null,
+	 *         falls die Schlange leer ist
+	 */
+	public ContentType front() {
+		if (this.isEmpty()) {
+			return null;
+		} else {
+			return head.getContent();
+		}
+	}
+}
diff --git a/README.TXT b/README.TXT
new file mode 100644
index 0000000..3475aa7
--- /dev/null
+++ b/README.TXT
@@ -0,0 +1,4 @@
+Implementierung der push- und pop-Operationen in der Stack-Klasse (Stapel) aus
+dem Zentralabitur NRW.
+
+Version: 2020-09-09
diff --git a/Stack.java b/Stack.java
new file mode 100644
index 0000000..4814bb3
--- /dev/null
+++ b/Stack.java
@@ -0,0 +1,126 @@
+ /**
+ * <p>
+ * Materialien zu den zentralen NRW-Abiturpruefungen im Fach Informatik ab 2018
+ * </p>
+ * <p>
+ * Generische Klasse Stack<ContentType>
+ * </p>
+ * <p>
+ * Objekte der generischen Klasse Stack (Keller, Stapel) verwalten beliebige
+ * Objekte vom Typ ContentType nach dem Last-In-First-Out-Prinzip, d.h., das
+ * zuletzt abgelegte Objekt wird als erstes wieder entnommen. Alle Methoden
+ * haben eine konstante Laufzeit, unabhaengig von der Anzahl der verwalteten
+ * Objekte.
+ * </p>
+ * 
+ * @author Qualitaets- und UnterstuetzungsAgentur - Landesinstitut fuer Schule
+ * @version Generisch_02 2014-02-21
+ */
+public class Stack<ContentType> {
+
+  /* --------- Anfang der privaten inneren Klasse -------------- */
+
+  private class StackNode {
+
+    private ContentType content = null;
+    private StackNode nextNode = null;
+
+    /**
+     * Ein neues Objekt vom Typ StackNode<ContentType> wird erschaffen. <br />
+     * Der Inhalt wird per Parameter gesetzt. Der Verweis ist leer.
+     * 
+     * @param pContent der Inhalt des Knotens
+     */
+    public StackNode(ContentType pContent) {
+      content = pContent;
+      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;
+    }
+
+    /**
+     * 
+     * @return das Objekt, auf das der aktuelle Verweis zeigt
+     */
+    public StackNode getNext() {
+      return nextNode;
+    }
+
+    /**
+     * @return das Inhaltsobjekt vom Typ ContentType
+     */
+    public ContentType getContent() {
+      return content;
+    }
+  }
+
+  /* ----------- Ende der privaten inneren Klasse -------------- */
+
+  private StackNode head;
+
+  /**
+   * Ein leerer Stapel wird erzeugt. Objekte, die in diesem Stapel verwaltet
+   * werden, muessen vom Typ ContentType sein.
+   */
+  public Stack() {
+    head = null;
+  }
+
+  /**
+   * Die Anfrage liefert den Wert true, wenn der Stapel keine Objekte
+   * enthaelt, sonst liefert sie den Wert false.
+   * 
+   * @return true, falls der Stapel leer ist, sonst false
+   */
+  public boolean isEmpty() {
+    return (head == null);
+  }
+
+  /**
+   * Das Objekt pContentType wird oben auf den Stapel gelegt. Falls
+   * pContentType gleich null ist, bleibt der Stapel unveraendert.
+   * 
+   * @param pContent 
+   *        das einzufuegende Objekt vom Typ ContentType
+   */
+  public void push(ContentType pContent) {
+    if (pContent != null) {
+      StackNode node = new StackNode(pContent);
+      node.setNext(head);
+      head = node;
+    }
+  }
+
+  /**
+   * Das zuletzt eingefuegte Objekt wird von dem Stapel entfernt. Falls der
+   * Stapel leer ist, bleibt er unveraendert.
+   */
+  public void pop() {
+    if (!isEmpty()) {
+      head = head.getNext();
+    }
+  }
+
+  /**
+   * Die Anfrage liefert das oberste Stapelobjekt. Der Stapel bleibt
+   * unveraendert. Falls der Stapel leer ist, wird null zurueckgegeben.
+   * 
+   * @return das oberste Stackelement vom Typ ContentType oder null, falls
+   *         der Stack leer ist
+   */
+  public ContentType top() {
+    if (!this.isEmpty()) {
+      return head.getContent();
+    } else {
+      return null;
+    }
+  }
+}
diff --git a/package.bluej b/package.bluej
new file mode 100644
index 0000000..2e4af65
--- /dev/null
+++ b/package.bluej
@@ -0,0 +1,52 @@
+#BlueJ package file
+dependency1.from=Stack
+dependency1.to=StackNode
+dependency1.type=UsesDependency
+dependency2.from=StackTest
+dependency2.to=Stack
+dependency2.type=UsesDependency
+editor.fx.0.height=777
+editor.fx.0.width=1123
+editor.fx.0.x=101
+editor.fx.0.y=23
+objectbench.height=95
+objectbench.width=776
+package.divider.horizontal=0.6
+package.divider.vertical=0.8118081180811808
+package.editor.height=433
+package.editor.width=653
+package.editor.x=140
+package.editor.y=80
+package.frame.height=600
+package.frame.width=800
+package.numDependencies=2
+package.numTargets=3
+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=StackNode
+target1.showInterface=false
+target1.type=ClassTarget
+target1.width=160
+target1.x=70
+target1.y=60
+target2.height=50
+target2.name=StackTest
+target2.showInterface=false
+target2.type=UnitTestTargetJunit4
+target2.width=90
+target2.x=430
+target2.y=110
+target3.height=50
+target3.name=Stack
+target3.showInterface=false
+target3.type=ClassTarget
+target3.width=160
+target3.x=80
+target3.y=300