mittelni
/
List-Queue-Stack-Set
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Compare commits

base: mittelni:master
Branches Tags
mittelni:master
..
compare: mittelni:e5a182a57fb9094a40c681532d3edf90b13075d9
Branches Tags
mittelni:master

No commits in common. "master" and "e5a182a57fb9094a40c681532d3edf90b13075d9" have entirely different histories.
master ... e5a182a57f

7 changed files with 9 additions and 200 deletions
Show Stats Expand all files Collapse all files

2
List-Queue-Stack-Set/.classpath
View File

@ -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-11">
<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>

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

@ -1,8 +1,8 @@
eclipse.preferences.version=1
org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
org.eclipse.jdt.core.compiler.codegen.targetPlatform=11
org.eclipse.jdt.core.compiler.codegen.targetPlatform=17
org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
org.eclipse.jdt.core.compiler.compliance=11
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
@ -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=11
org.eclipse.jdt.core.compiler.source=17

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

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

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

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

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

@ -1,48 +1,4 @@
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
}
public class AusführerSet {
}

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

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

149
List-Queue-Stack-Set/src/Set.java
View File

@ -1,151 +1,4 @@
public class Set<X> {
public class Set {
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");
}
}