Start

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>

List-Queue-Stack-Set/.gitignore

@@ -0,0 +1 @@
+/bin/

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>

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

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
+		
+	}
+}
+

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
+		
+	}
+}

List-Queue-Stack-Set/src/AusführerSet.java

@@ -0,0 +1,4 @@
+
+public class AusführerSet {
+
+}

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
+	}
+	
+}

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
+			}
+	}
+	
+}
+

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;
+	}
+	
+}

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
+			}
+	}
+	
+}

List-Queue-Stack-Set/src/Set.java

@@ -0,0 +1,4 @@
+
+public class Set {
+
+}

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
+			}
+	}
+	
+}