commit e1578d3e5f0a2733ce157aa3feaf9716806250d1 Author: mittelni Date: Wed Feb 23 10:44:30 2022 +0100 Start 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 @@ + + + + + + + + + + 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 @@ + + + List-Queue-Stack-Set + + + + + + org.eclipse.jdt.core.javabuilder + + + + + + org.eclipse.jdt.core.javanature + + 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 Liste = new List(); //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 Queue = new Queue(); + + 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 Stack = new Stack(); + + 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 { + + private Node 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(wert); //dann wird der Startwert zum ersten Knoten indem er den eingegebenen "wert" als Wert enthält + } else { //ansonsten + Node 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(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 Neu = new Node(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 Neu = new Node(wert); //neuer Knoten wird erstellt mit dem wert "wert" + Node 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 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 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 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 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 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 { //erstellt einen knoten + + public A wert; //wert des knoten bzw der "Name" + public Node 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 { + + private Node 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(wert); //dann wird der Startwert zum ersten Knoten indem er den eingegebenen "wert" als Wert enthält + } else { //ansonsten + Node 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(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 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 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 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 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 { + + private Node 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 Neu = new Node(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 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 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 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 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 + } + } + +}