Fertigstellung SET 10.3.2022

List-Queue-Stack-Set/.classpath

@@ -1,6 +1,6 @@
 <?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">
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-11">
 		<attributes>
 			<attribute name="module" value="true"/>
 		</attributes>

List-Queue-Stack-Set/.settings/org.eclipse.jdt.core.prefs

@@ -1,8 +1,8 @@
 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.targetPlatform=11
 org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
-org.eclipse.jdt.core.compiler.compliance=17
+org.eclipse.jdt.core.compiler.compliance=11
 org.eclipse.jdt.core.compiler.debug.lineNumber=generate
 org.eclipse.jdt.core.compiler.debug.localVariable=generate
 org.eclipse.jdt.core.compiler.debug.sourceFile=generate
@@ -11,4 +11,4 @@ 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
+org.eclipse.jdt.core.compiler.source=11

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

@@ -1,5 +1,5 @@
 
-public class Ausführer {
+public class Ausführer {
 
 	public static void main(String[] args) {
 		

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

@@ -1,5 +1,5 @@
 
-public class AusführerQueue {
+public class AusführerQueue {
 	
 	public static void main(String[] args) {
 		

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

@@ -1,4 +1,48 @@
 
-public class AusführerSet {
+public class AusführerSet {
+	
+	public static void main(String[] args) {
+		
+		Set<Integer> Set = new Set<Integer>();
+		Set<Integer> Set2 = new Set<Integer>();
+		Set<Integer> Set3 = new Set<Integer>();
+		
+		Set.add(1);//fügt neue variable der Liste an
+		Set.add(3);//fügt neue variable der Liste an
+		Set.add(5);//fügt neue variable der Liste an
+		Set.add(7);//fügt neue variable der Liste an
+		Set.add(9);//fügt neue variable der Liste an
+		
+		Set2.add(2);//fügt neue variable der Liste zweiten Liste an
+		Set2.add(3);//fügt neue variable der Liste zweiten Liste an
+		Set2.add(4);//fügt neue variable der Liste zweiten Liste an
+		Set2.add(6);//fügt neue variable der Liste zweiten Liste an
+		Set2.add(9);//fügt neue variable der Liste zweiten Liste an
+		
+		Set3.add(3);//fügt neue variable der Liste dritten Liste an
+		Set3.add(5);//fügt neue variable der Liste dritten Liste an
+		
+		System.out.println(Set.contains(4)); //kontrolliert ob eine bestimme variable in der liste vorhanden ist und gibt das ergebnis aus
+		
+		System.out.println(Set.isEmpty());	//kontrolliert ob die liste leer ist und gibt das ergebnis aus
+		
+		Set.remove(7); //entfernt eine bstimme variable 
+		
+		Set<Integer> I = Set.intersection(Set2);//fügt variablen die in beiden listen vorhanden sind in einer zusammen
+		I.Ausgabe();//gibt diese liste aus
+		
+		Set<Integer> U = Set.union(Set2);	//fügt alle werte in beiden listen in eine zusammen
+		U.Ausgabe();//gibt diese liste aus
+		
+		Set<Integer> D = Set.difference(Set2);	//fügt alle wert in eine extra liste die nur in der ersten nicht in der zweiten liste sind
+		D.Ausgabe();//gibt iese liste aus
+		
+		System.out.println(Set.subset(Set3));	//Methode die kontrolliert ob alle variablen in der eingegebnene Liste auchn in der ersten Liste sind
+		
+		System.out.println(Set.size()); //gibt die größe der liste aus
+		
+		Set.Ausgabe();	//gibt die einzelnen variablen in der liste aus
+		
+	}
 
 }

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

@@ -1,5 +1,5 @@
 
-public class AusführerStack {
+public class AusführerStack {
 
 	public static void main(String[] args) {
 		

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

@@ -1,4 +1,151 @@
 
-public class Set {
+public class Set<X> {
 
+	private Node<X> start;	
+	
+	private int size; //variable für die größe
+	
+	public Set() {			//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 boolean contains(X wert) {									//Methode um herauszufinden ob ein bestimmter wert in der Liste vorhanden ist
+		Node<X> 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 void add(X wert) {
+		if(contains(wert) == false) {
+			this.size++;											
+			
+			if(this.start == null) {							
+				this.start = new Node<X>(wert);			
+			} else { 
+				Node<X> current = this.start;		
+				while (current.next != null) {				
+					current = current.next;	
+	
+				}
+				current.next = new Node<X>(wert);
+			}
+			
+		} else {
+			return;
+		}
+		
+	}
+	
+	public void remove(X wert) {//methode um dne wert an einer bestimmten stelle zu entfernen
+		Node<X> current = this.start;//initialisiert den Knoten current
+		if(current.wert == wert) {	//wenn der aktuelle wert dem eingegebenen entspricht
+			this.start = current.next;	//wird der start zur nächsten variable
+			size--;	//1 wind von der größe subtrahiert
+		}
+			while(current.next != null) {	//wärend die nächste variable ungleich null ist
+				if(current.next.wert == wert) {	//wenn der nächste wert gleich dem eingegebenen wert ist
+					current.next = current.next.next;	//wird die nächste variable zur übernächsten
+					size--;	//1 wird von der größe abgezogen
+				} else {	//ansonsten
+					current = current.next;	//wird der aktuelle wert zum nächsten
+				}
+			
+			}
+	}
+	
+	public Set<X> intersection(Set<X> s) {	//methode die Variablen die in beiden listen vorhanden sind in einer list zusammen
+		Set<X> result = new Set<X>();	//neue Liste zur Ausgabe
+		Node<X> current = this.start;	//initialisiert die liste
+		while(current != null) {	//wärend current ungleich null ist
+			if(s.contains(current.wert)) result.add(current.wert);	//wenn die liste s den wert enthält dann wird der wert in die ausgabeliste hinzugefügt
+			current = current.next; //current wird zur nächsten variable
+		}
+		return result;	//gibt die ausgabeliste zurück
+	}
+	
+	public Set<X> union(Set<X> s) {	//Methode die alle werte aus beiden listen in eine packt
+		Node<X> current = this.start;	//initialisiert die erste liste
+		Node<X> current2 = s.start; //initialisiert die zweite liste
+		Set<X> result = new Set<X>(); //erstellet eine Liste zum ausgeben
+		
+		result.add(current.wert);	//fügt wert der ausgabeliste hinzu
+		
+			for(int i = 0; i < this.size(); i++) {	
+				for(int j = 0; j < s.size(); j++) { 
+					if(result.contains(current.wert) == false) { //wenn result bereits den wert enthält wird er nicht hinzugefügt
+						result.add(current.wert);//fügt den wert hinzu
+					}
+					if(result.contains(current2.wert) == false) { //wenn result bereits den wert enthält wird er nicht hinzugefügt
+						result.add(current2.wert);//fügt den wert hinzu
+					}
+					current2 = current2.next; //geht zur nächsetn variable der zweiten liste
+				}
+				current = current.next; //geht zur nächsten variable der ersten liste
+				current2 = s.start;	//current der zweiten liste wird zum start der zweiten eingegebenen liste
+			}
+			return result; //gibt die ausgabeliste zurück
+		}
+	
+	public Set<X> difference(Set<X> s) {	//methode die alle variablen die nur in der ersten nicht in der zweiten liste sind in eine extra ausgabeliste packt
+		Node<X> current = this.start;	//initialisiert die liste
+		Set<X> result = new Set<X>();	//erstellt neue liste zum ausgeben
+		
+			for(int i = 0; i < this.size(); i++) {	
+				for(int j = 0; j < s.size(); j++) {
+					if(result.contains(current.wert) == false) //wenn result den wert nicht enthält
+						if(s.contains(current.wert) == false) {//wenn s den wert nicht enthält
+							result.add(current.wert); //wert wird zu result hinzugefügt
+					}
+				}
+				current = current.next; //nächste variable
+			}
+			return result;//gibt die Ausgabeliste zurück
+	}
+	
+	public boolean subset(Set<X> s) {	//Methode die kontrolliert ob alle variablen in der eingegebnene Liste auchn in der ersten Liste sind
+        Node<X> current2 = s.start;	//initialisiert die liste s
+        while(current2 != null) { //wärend der nächste wert ungleich null ist
+            if(this.contains(current2.wert) == true) { //wenn die erste liste den wert enthält
+                 current2 = current2.next;	//zur nächsten variable gehen
+            } else {
+            	return false;	//wenn nicht abbrechen
+            }
+        }
+        return true; //falls alle drinnen sind true zurück geben
+
+    }
+	
+	public Node<X> 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<X> 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
+	}System.out.print("\n");
+}
+	
 }