From e1578d3e5f0a2733ce157aa3feaf9716806250d1 Mon Sep 17 00:00:00 2001
From: mittelni <mittelni@10.16.255.67>
Date: Wed, 23 Feb 2022 10:44:30 +0100
Subject: [PATCH] Start
---
List-Queue-Stack-Set/.classpath | 10 ++
List-Queue-Stack-Set/.gitignore | 1 +
List-Queue-Stack-Set/.project | 17 +++
.../.settings/org.eclipse.jdt.core.prefs | 14 ++
List-Queue-Stack-Set/src/Ausführer.java | 32 +++++
List-Queue-Stack-Set/src/AusführerQueue.java | 25 ++++
List-Queue-Stack-Set/src/AusführerSet.java | 4 +
List-Queue-Stack-Set/src/AusführerStack.java | 25 ++++
List-Queue-Stack-Set/src/List.java | 124 ++++++++++++++++++
List-Queue-Stack-Set/src/Node.java | 11 ++
List-Queue-Stack-Set/src/Queue.java | 73 +++++++++++
List-Queue-Stack-Set/src/Set.java | 4 +
List-Queue-Stack-Set/src/Stack.java | 69 ++++++++++
13 files changed, 409 insertions(+)
create mode 100755 List-Queue-Stack-Set/.classpath
create mode 100644 List-Queue-Stack-Set/.gitignore
create mode 100755 List-Queue-Stack-Set/.project
create mode 100755 List-Queue-Stack-Set/.settings/org.eclipse.jdt.core.prefs
create mode 100755 List-Queue-Stack-Set/src/Ausführer.java
create mode 100755 List-Queue-Stack-Set/src/AusführerQueue.java
create mode 100755 List-Queue-Stack-Set/src/AusführerSet.java
create mode 100755 List-Queue-Stack-Set/src/AusführerStack.java
create mode 100755 List-Queue-Stack-Set/src/List.java
create mode 100755 List-Queue-Stack-Set/src/Node.java
create mode 100755 List-Queue-Stack-Set/src/Queue.java
create mode 100755 List-Queue-Stack-Set/src/Set.java
create mode 100755 List-Queue-Stack-Set/src/Stack.java
diff --git a/List-Queue-Stack-Set/.classpath b/List-Queue-Stack-Set/.classpath
new file mode 100755
index 0000000..57bca72
--- /dev/null
+++ b/List-Queue-Stack-Set/.classpath
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-17">
+ <attributes>
+ <attribute name="module" value="true"/>
+ </attributes>
+ </classpathentry>
+ <classpathentry kind="src" path="src"/>
+ <classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/List-Queue-Stack-Set/.gitignore b/List-Queue-Stack-Set/.gitignore
new file mode 100644
index 0000000..ae3c172
--- /dev/null
+++ b/List-Queue-Stack-Set/.gitignore
@@ -0,0 +1 @@
+/bin/
diff --git a/List-Queue-Stack-Set/.project b/List-Queue-Stack-Set/.project
new file mode 100755
index 0000000..8b0612b
--- /dev/null
+++ b/List-Queue-Stack-Set/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+ <name>List-Queue-Stack-Set</name>
+ <comment></comment>
+ <projects>
+ </projects>
+ <buildSpec>
+ <buildCommand>
+ <name>org.eclipse.jdt.core.javabuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ </buildSpec>
+ <natures>
+ <nature>org.eclipse.jdt.core.javanature</nature>
+ </natures>
+</projectDescription>
diff --git a/List-Queue-Stack-Set/.settings/org.eclipse.jdt.core.prefs b/List-Queue-Stack-Set/.settings/org.eclipse.jdt.core.prefs
new file mode 100755
index 0000000..8c9943d
--- /dev/null
+++ b/List-Queue-Stack-Set/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,14 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=17
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=17
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=warning
+org.eclipse.jdt.core.compiler.release=enabled
+org.eclipse.jdt.core.compiler.source=17
diff --git a/List-Queue-Stack-Set/src/Ausführer.java b/List-Queue-Stack-Set/src/Ausführer.java
new file mode 100755
index 0000000..c77bb99
--- /dev/null
+++ b/List-Queue-Stack-Set/src/Ausführer.java
@@ -0,0 +1,32 @@
+
+public class Ausführer {
+
+ public static void main(String[] args) {
+
+ List<Integer> Liste = new List<Integer>(); //initialisiert die Liste
+
+ Liste.add(6); //fügt der liste den Wert 6 an
+ Liste.add(5); //fügt der liste den Wert 5 an
+ Liste.add(3); //fügt der liste den Wert 3 an
+ Liste.add(2); //fügt der liste den Wert 2 an
+
+ System.out.println(Liste.isEmpty()); //testet ob die liste leer ist
+
+ System.out.println(Liste.size()); //giibt die größe der liste aus
+
+ Liste.add(7, 1); //fügt der Liste den Wert 7 an der ersten Stelle an
+ Liste.add(4, 4); //fügt der Liste den Wert 4 an der vierten Stelle an
+ Liste.add(1, 7); //fügt der liste den Wert 1 an der siebten Stelle an
+
+ System.out.println(Liste.get(2)); //gibt den Wert an der zweiten Stelle der Liste aus
+
+ System.out.println(Liste.contains(5)); //testet ob der Wert 5 in der Liste vorhanden ist und gibt das ergebnis aus
+ System.out.println(Liste.contains(10)); //testet ob der Wert 10 in der liste vorhanden ist und gibt das ergebnis aus
+
+ System.out.println(Liste.remove(1)); //entfernt den Wert an der ersten Stelle der Liste und gibt ihn zurück
+
+ Liste.Ausgabe(); //gibt die Liste aus
+
+ }
+}
+
diff --git a/List-Queue-Stack-Set/src/AusführerQueue.java b/List-Queue-Stack-Set/src/AusführerQueue.java
new file mode 100755
index 0000000..fcf4da2
--- /dev/null
+++ b/List-Queue-Stack-Set/src/AusführerQueue.java
@@ -0,0 +1,25 @@
+
+public class AusführerQueue {
+
+ public static void main(String[] args) {
+
+ Queue<Integer> Queue = new Queue<Integer>();
+
+ Queue.enqueue(7); //fügt der liste den Wert 7 an
+ Queue.enqueue(6); //fügt der liste den Wert 6 an
+ Queue.enqueue(5); //fügt der liste den Wert 5 an
+ Queue.enqueue(4); //fügt der liste den Wert 4 an
+ Queue.enqueue(3); //fügt der liste den Wert 3 an
+ Queue.enqueue(2); //fügt der liste den Wert 2 an
+ Queue.enqueue(1); //fügt der liste den Wert 1 an
+
+ System.out.println(Queue.isEmpty()); //testet ob die Liste leer ist
+
+ System.out.println(Queue.dequeue()); //Methode die den ersten wert entfernt und ausgibt oder "null" falls sie leer ist
+
+ System.out.println(Queue.front()); //Methode die den ersten wert ausgibt oder "null" falls sie leer ist
+
+ Queue.Ausgabe(); //gibt die Liste aus
+
+ }
+}
\ No newline at end of file
diff --git a/List-Queue-Stack-Set/src/AusführerSet.java b/List-Queue-Stack-Set/src/AusführerSet.java
new file mode 100755
index 0000000..6847c55
--- /dev/null
+++ b/List-Queue-Stack-Set/src/AusführerSet.java
@@ -0,0 +1,4 @@
+
+public class AusführerSet {
+
+}
diff --git a/List-Queue-Stack-Set/src/AusführerStack.java b/List-Queue-Stack-Set/src/AusführerStack.java
new file mode 100755
index 0000000..31a1263
--- /dev/null
+++ b/List-Queue-Stack-Set/src/AusführerStack.java
@@ -0,0 +1,25 @@
+
+public class AusführerStack {
+
+ public static void main(String[] args) {
+
+ Stack<Integer> Stack = new Stack<Integer>();
+
+ Stack.push(1); //fügt der liste den Wert 1 oben drauf
+ Stack.push(2); //fügt der liste den Wert 2 oben drauf
+ Stack.push(3); //fügt der liste den Wert 3 oben drauf
+ Stack.push(4); //fügt der liste den Wert 4 oben drauf
+ Stack.push(5); //fügt der liste den Wert 5 oben drauf
+ Stack.push(6); //fügt der liste den Wert 6 oben drauf
+ Stack.push(7); //fügt der liste den Wert 7 oben drauf
+
+ System.out.println(Stack.isEmpty()); //testet ob die lste leer ist
+
+ System.out.println(Stack.pop()); //entfernt das oberste Element der stacks und gibt den darauf gespeicherten wert aus oder "null"
+
+ System.out.println(Stack.top()); //gibt den obersten wert des stacks aus oder "null"
+
+ Stack.Ausgabe(); //gibt die Liste aus
+ }
+
+}
diff --git a/List-Queue-Stack-Set/src/List.java b/List-Queue-Stack-Set/src/List.java
new file mode 100755
index 0000000..fa7cd29
--- /dev/null
+++ b/List-Queue-Stack-Set/src/List.java
@@ -0,0 +1,124 @@
+
+public class List<A> {
+
+ private Node<A> start; //initialisiert den Start der Liste bzw des ersten knoten
+
+ private int size; //initialisiert die größe der Liste bzw die variable dafür
+
+ public List() { //Konstrukter der die Startwertde der liste angibt
+ this.start = null; //Startwert für "start" ist "null"
+ this.size = 0; //Startwert für die größe alos "size" ist 0
+ }
+
+ public boolean isEmpty() { //Methode für den test ob die liste leer ist
+ if(size == 0) { //solange die größe noch 0 ist
+ return true; //positiver ergebnis, dass die Liste leer ist
+ } else { //ansonsten
+ return false; //negative ergebnis, ass die liste Werte enthält
+ }
+ }
+
+ public void add(A wert) { //Methode für das anfüger eines Wertes bzw Elementes an der Liste
+ this.size++; //erhöht die größe der liste um 1
+
+ if(this.start == null) { //wenn der Startwert noch "null" ist
+ this.start = new Node<A>(wert); //dann wird der Startwert zum ersten Knoten indem er den eingegebenen "wert" als Wert enthält
+ } else { //ansonsten
+ Node<A> current = this.start; //der aktuelle Knoten bekommt den wert start
+ while (current.next != null) { //wärend der Startwert des nächsten knoten ungleich "null" ist
+ current = current.next; //geht er zum nächsten knoten
+ }
+ current.next = new Node<A>(wert); //der nächste Knoten ist ein neuer mit dem Wert "wert"
+ }
+ }
+
+ public void add(A wert, int ort) { //Methode für das einfügen von neuen elementen bzw Werten
+ if(ort < size) { //wenn der ort zu dem man will kleiner als die gesamtgröße der Liste ist
+ size++; //größe der Liste wird um 1 erhöht
+ if(ort < 2) { //wenn der ort nicht nur kleiner als die gesamtgröße ist sondern auch noch kleiner als der zweite, also der erste wert der liste
+ Node<A> Neu = new Node<A>(wert); //neuer knoten der den eingegebenen wert als "wert" erhält um den dann an der richtigen stelle einzuschieben
+ Neu.next = start; //der neue Knoten wird zum start Knoten
+ start = Neu; //der "Neu.next" wird mit der Zeile drüber zu "Neu"
+ } else { //ansonsten
+ Node<A> Neu = new Node<A>(wert); //neuer Knoten wird erstellt mit dem wert "wert"
+ Node<A> current = this.start; //der aktuelle knoten wird zum start Knoten
+
+ int a = 0; //neue variable zum hochzählen
+
+ while (a != ort - 2) { //während a ungleich dem hinzuzählenden ort - 2 ist
+ current = current.next; //wird jedes mal wenn... ...wird der nächste wert zum aktuellen
+ a++; //...a um 1 erhöht wird...
+ }
+
+ Neu.next = current.next; //der nächste wert vom neuen knoten wird zum nächsten wert vom aktuellen knoten
+ current.next = Neu; //und der nächste wert vom aktuellen Knoten wird zum wert vom neuen knoten
+ }
+ } else { //ansonsten
+ add(wert); //wird der Wert einfach hinten angefügt mit der dazu bereits bestehenden Methode
+ }
+ }
+
+
+ public A get(int ort) { //Methode um den Wert an einer bestimmten stelle zu bekommen
+
+ Node<A> current = this.start; //Knoten current wird initialisiert
+
+ for(int i = 0; i < ort; i++) { //for schleife zum durchgehen der liste
+ current = current.next; //macht den nächsten wert zum aktuellen
+ }
+ A I = current.wert; //speichert den Wert in einer Variable
+ return I; //gibt die variable zurück
+ }
+
+ public boolean contains(A wert) { //Methode um herauszufinden ob ein bestimmter wert in der Liste vorhanden ist
+ Node<A> current = this.start; //initialisiert den knoten current
+ while(current != null) { //wärend der wert von current ungleicht "null" ist
+
+ if(current.wert == wert) { //wenn der Wert von current gleich dem eingegebenen "wert" ist
+ return true; //positives ergebnis für den durchgeführten test
+ }
+ current = current.next; //nächste wert von current wird zum aktuellen
+
+ }
+ return false; //negatives ergebnis für den durchgeführten test
+ }
+
+ public A remove(int ort) { //methode um dne wert an einer bestimmten stelle zu entfernen
+ Node<A> current = this.start; //initialisiert den Knoten current
+ if(ort > size){ //wenn der ort nicht in der Liste ist null zurück geben
+ return null;
+ }
+ if(ort > 1) { //wenn der ort kleiner als 1 ist
+ int f = 1; //duchrchzählvariable
+ while(f != ort-1) { //während die variable ungleich dem ort - 1 ist
+ current = current.next; //wird der nächste wert zum aktuallen
+ f++; //f wird um 1 hochgezählt
+ }
+ current.next = current.next.next; //der nächste wert ist der übernächste wert
+ size--; //1 von der größe abziehen da ja ein wert entfernt wird
+ } else { //ansonsten
+ this.start = current.next; //start wird zum nächsten wert vom aktuellen knoten aus
+ }
+ A I = current.wert;
+ return I;
+ }
+
+ public Node<A> getStart() { //erstellt start zum getten
+ return this.start; //gibt start zurück
+ }
+
+ public int size() { //erstellt size zum getten
+ return this.size; //gibt size zurück
+ }
+
+ public void Ausgabe() {
+ Node<A> current = this.start; //initialisiert die liste
+
+ while(current != null) { //solange current also der aktuelle Wert ungleich "null" ist
+ System.out.print(current.wert + " "); //gibt den aktuellen Wert aus
+ current = current.next; //geht zum nächsten Wert
+ }
+ }
+
+}
+
diff --git a/List-Queue-Stack-Set/src/Node.java b/List-Queue-Stack-Set/src/Node.java
new file mode 100755
index 0000000..1f9e2d2
--- /dev/null
+++ b/List-Queue-Stack-Set/src/Node.java
@@ -0,0 +1,11 @@
+
+public class Node<A> { //erstellt einen knoten
+
+ public A wert; //wert des knoten bzw der "Name"
+ public Node<A> next; //"Name" des n‰chsten knoten
+
+ public Node(A z) { //gibt Startwert des Knoten btw den "Namen"
+ wert = z;
+ }
+
+}
diff --git a/List-Queue-Stack-Set/src/Queue.java b/List-Queue-Stack-Set/src/Queue.java
new file mode 100755
index 0000000..5223554
--- /dev/null
+++ b/List-Queue-Stack-Set/src/Queue.java
@@ -0,0 +1,73 @@
+
+public class Queue<Q> {
+
+ private Node<Q> start; //initialisiert den Start der Liste bzw des ersten knoten
+
+ private int size; //initialisiert die größe der Liste bzw die variable dafür
+
+ public Queue() { //Konstrukter der die Startwertde der liste angibt
+ this.start = null; //Startwert für "start" ist "null"
+ this.size = 0; //Startwert für die größe alos "size" ist 0
+ }
+
+ public boolean isEmpty() { //Methode für den test ob die liste leer ist
+ if(size == 0) { //solange die größe noch 0 ist
+ return true; //positiver ergebnis, dass die Liste leer ist
+ } else { //ansonsten
+ return false; //negative ergebnis, ass die liste Werte enthält
+ }
+ }
+
+ public void enqueue(Q wert) {//Methode für das anfüger eines Wertes bzw Elementes an der Queue
+ this.size++; //erhöht die größe der liste um 1
+
+ if(this.start == null) { //wenn der Startwert noch "null" ist
+ this.start = new Node<Q>(wert); //dann wird der Startwert zum ersten Knoten indem er den eingegebenen "wert" als Wert enthält
+ } else { //ansonsten
+ Node<Q> current = this.start; //der aktuelle Knoten bekommt den wert start
+ while (current.next != null) { //wärend der Startwert des nächsten knoten ungleich "null" ist
+ current = current.next; //geht er zum nächsten knoten
+ }
+ current.next = new Node<Q>(wert); //der nächste Knoten ist ein neuer mit dem Wert "wert"
+ }
+ }
+
+ public Q dequeue() { //Methode löscht den ertsen wert und gibt ihn zurück oder gibt "null" zurück
+ Node<Q> current = this.start; //initialisiert den Knoten current
+ if(isEmpty() == true) { //wenn das Ergebnis aus isEmpty() true ist...
+ return null; //...stoppt er
+ } else { //ansonsten
+ Q I = current.wert; //speichert den wert in I
+ this.start = current.next; //start wird zum nächsten wert vom aktuellen Knoten aus
+ return I; //gibt den wert zurück
+ }
+ }
+
+ public Q front() { //Methode gibt den ertsen wert zurück oder "null"
+ Node<Q> current = this.start; //initialisiert den Knoten current
+ if(isEmpty() == true) { //wenn das Ergebnis aus isEmpty() true ist...
+ return null; //...stoppt er
+ } else {
+ Q I = current.wert; //speichert den wert in I
+ return I; // gibt den wert zurück
+ }
+ }
+
+ public Node<Q> getStart() { //erstellt start zum getten
+ return this.start; //gibt start zurück
+ }
+
+ public int size() { //erstellt size zum getten
+ return this.size; //gibt size zurück
+ }
+
+ public void Ausgabe() {
+ Node<Q> current = this.start; //initialisiert die liste
+
+ while(current != null) { //solange current also der aktuelle Wert ungleich "null" ist
+ System.out.print(current.wert + " "); //gibt den aktuellen Wert aus
+ current = current.next; //geht zum nächsten Wert
+ }
+ }
+
+}
diff --git a/List-Queue-Stack-Set/src/Set.java b/List-Queue-Stack-Set/src/Set.java
new file mode 100755
index 0000000..f18e3e7
--- /dev/null
+++ b/List-Queue-Stack-Set/src/Set.java
@@ -0,0 +1,4 @@
+
+public class Set {
+
+}
diff --git a/List-Queue-Stack-Set/src/Stack.java b/List-Queue-Stack-Set/src/Stack.java
new file mode 100755
index 0000000..14add48
--- /dev/null
+++ b/List-Queue-Stack-Set/src/Stack.java
@@ -0,0 +1,69 @@
+
+public class Stack<S> {
+
+ private Node<S> start; //initialisiert den Start der Liste bzw des ersten knoten
+
+ private int size; //initialisiert die größe der Liste bzw die variable dafür
+
+ public Stack() { //Konstrukter der die Startwertde der liste angibt
+ this.start = null; //Startwert für "start" ist "null"
+ this.size = 0; //Startwert für die größe alos "size" ist 0
+ }
+
+
+ public boolean isEmpty() { //Methode für den test ob die liste leer ist
+ if(size == 0) { //solange die größe noch 0 ist
+ return true; //positiver ergebnis, dass die Liste leer ist
+ } else { //ansonsten
+ return false; //negative ergebnis, ass die liste Werte enthält
+ }
+ }
+
+ public void push(S wert) {
+ size++;
+
+ Node<S> Neu = new Node<S>(wert); //neuer knoten der den eingegebenen wert als "wert" erhält um den dann an der richtigen stelle einzuschieben
+ Neu.next = start; //der neue Knoten wird zum start Knoten
+ start = Neu; //der "Neu.next" wird mit der Zeile drüber zu "Neu"
+
+ }
+
+ public S pop() { //entfernt das oberste Element der stacks und gibt den darauf gespeicherten wert aus oder "null"
+ Node<S> current = this.start; //initialisiert den Knoten current
+ if(isEmpty() == true) { //wenn das Ergebnis aus isEmpty() true ist...
+ return null; //...stoppt er
+ } else { //ansonsten
+ S I = current.wert; //speiichert den wert in I
+ this.start = current.next; //start wird zum nächsten wert vom aktuellen Knoten aus
+ return I; //gibt den wert zurück
+ }
+ }
+
+ public S top() { //gibt den obersten wert des stacks aus oder "null"
+ Node<S> current = this.start; //initialisiert den Knoten current
+ if(isEmpty() == true) { //wenn das Ergebnis aus isEmpty() true ist...
+ return null; //...stoppt er
+ } else {
+ S I = current.wert; //speichert den wert in I
+ return I; //gibt den wert aus
+ }
+ }
+
+
+ public Node<S> getStart() { //erstellt start zum getten
+ return this.start; //gibt start zurück
+ }
+
+ public int size() { //erstellt size zum getten
+ return this.size; //gibt size zurück
+ }
+ public void Ausgabe() {
+ Node<S> current = this.start; //initialisiert die liste
+
+ while(current != null) { //solange current also der aktuelle Wert ungleich "null" ist
+ System.out.print(current.wert + " "); //gibt den aktuellen Wert aus
+ current = current.next; //geht zum nächsten Wert
+ }
+ }
+
+}