10.03.22 Update
Mischa
parent
818be00c30
commit
6da8f3842d
|
|
@ -1,98 +1,160 @@
|
|||
|
||||
public class Set<P> {
|
||||
private Node<P> start;
|
||||
private int size;
|
||||
|
||||
|
||||
private Node<P> start;
|
||||
private int size;
|
||||
|
||||
public Set() {
|
||||
this.start = null;
|
||||
this.size = 0;
|
||||
}
|
||||
public boolean isEmpty() { // Klasse fragt ab ob die liste leer ist
|
||||
if (size == 0) { // wenn l‰nge der liste 0 ist
|
||||
|
||||
return true; // gibt true zur¸ck weil es boolean ist
|
||||
} else { // wenn oberes nicht erfÔøΩllt wird
|
||||
|
||||
return false; // gibt false zur¸ck wegen boolean
|
||||
this.start = null;
|
||||
this.size = 0;
|
||||
}
|
||||
}
|
||||
public void add(P wert) { // Methode f‰ngt hinten an die Liste etwas an
|
||||
this.size++; // grˆfle wird hochgez‰hlt da liste um ein grˆfler werden muss
|
||||
if(contains(wert) == false) {
|
||||
if (this.start == null) { // wenn start wert = 0 ist
|
||||
this.start = new Node<P>(wert); // start wird zu neuem Knoten mit wert wert
|
||||
} else { // wenn obere if bedingung nicht erf¸llt wird dann soll er volgendes ausgef¸hrt
|
||||
Node<P> current = this.start; // current bekommt den wert der start zugewissen wurde
|
||||
while (current.next != null) { // w‰hrend nachfolger des jetzigen Knotens ungleich null ist
|
||||
current = current.next; // wird current dem n‰chsten werd zugewissen
|
||||
|
||||
}
|
||||
current.next = new Node<P>(wert); // dem jetzigen Knoten wird als 2ter eintrag ein neuer Knoten zugewissen
|
||||
public boolean isEmpty() { // Klasse fragt ab ob die liste leer ist
|
||||
if (size == 0) { // wenn l‰nge der liste 0 ist
|
||||
|
||||
return true; // gibt true zur¸ck weil es boolean ist
|
||||
} else { // wenn oberes nicht erfÔøΩllt wird
|
||||
|
||||
return false; // gibt false zur¸ck wegen boolean
|
||||
}
|
||||
} else {return;}
|
||||
}
|
||||
|
||||
public boolean contains(P wert) { //gibt aus ob ein wert in der Liste ist
|
||||
Node<P> current = this.start; // Knoten current wird der wert start zugewissen
|
||||
while (current != null) { // solange current ungleich null ist wird das in der Schleife ausgefÔøΩhrt
|
||||
public void add(P wert) { // Methode f‰ngt hinten an die Liste etwas an
|
||||
this.size++; // grˆfle wird hochgez‰hlt da liste um ein grˆfler werden muss
|
||||
if (contains(wert) == false) {
|
||||
if (this.start == null) { // wenn start wert = 0 ist
|
||||
this.start = new Node<P>(wert); // start wird zu neuem Knoten mit wert wert
|
||||
} else { // wenn obere if bedingung nicht erf¸llt wird dann soll er volgendes
|
||||
// ausgef¸hrt
|
||||
Node<P> current = this.start; // current bekommt den wert der start zugewissen wurde
|
||||
while (current.next != null) { // w‰hrend nachfolger des jetzigen Knotens ungleich null ist
|
||||
current = current.next; // wird current dem n‰chsten werd zugewissen
|
||||
|
||||
if (current.wert == wert) { // wenn der der Knoten current = der wert ist
|
||||
|
||||
return true; // dann gibt es den eintrag also muss er true zurÔøΩckgeben
|
||||
}
|
||||
current.next = new Node<P>(wert); // dem jetzigen Knoten wird als 2ter eintrag ein neuer Knoten
|
||||
// zugewissen
|
||||
}
|
||||
current = current.next; // n‰chster wert wird zum aktuellen
|
||||
} else {
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
public boolean contains(P wert) { // gibt aus ob ein wert in der Liste ist
|
||||
Node<P> current = this.start; // Knoten current wird der wert start zugewissen
|
||||
while (current != null) { // solange current ungleich null ist wird das in der Schleife ausgefÔøΩhrt
|
||||
|
||||
if (current.wert == wert) { // wenn der der Knoten current = der wert ist
|
||||
|
||||
return true; // dann gibt es den eintrag also muss er true zurÔøΩckgeben
|
||||
}
|
||||
current = current.next; // n‰chster wert wird zum aktuellen
|
||||
|
||||
}
|
||||
|
||||
return false; // sonst ist er nicht drin
|
||||
}
|
||||
public void remove(P wert) {
|
||||
Node<P> current = this.start; // neuer Knoten current wird erstellt
|
||||
if(current.wert == wert) {
|
||||
this.start = current.next;
|
||||
}
|
||||
while(current.next != null) {
|
||||
if(current.next.wert == wert) {
|
||||
current.next = current.next.next;
|
||||
size--;
|
||||
}
|
||||
current = current.next;
|
||||
}
|
||||
}
|
||||
public void Ausgabe() {
|
||||
Node<P> current = this.start;
|
||||
|
||||
while(current != null) {
|
||||
System.out.print(current.wert + " ");
|
||||
current = current.next;
|
||||
} System.out.print("\n");
|
||||
}
|
||||
public int size() { // getter Mehode f¸r grˆfle
|
||||
return false; // sonst ist er nicht drin
|
||||
}
|
||||
|
||||
public void remove(P wert) {
|
||||
Node<P> current = this.start; // neuer Knoten current wird erstellt
|
||||
if (current.wert == wert) { //wenn der wert in current gleich der wert ist
|
||||
this.start = current.next; //wenn der wert von start wird auf den wert im nächsten Node ist
|
||||
}
|
||||
while (current.next != null) { //solange der nächste wert in Node ungleich null ist
|
||||
if (current.next.wert == wert) { //wenn der wert vom nächsten Node gleich der wert ist
|
||||
current.next = current.next.next; //der nächste wert von Node wir auf den übernächsten gesetzt
|
||||
size--; //größe der Node wird eins runter gezählt um den eintrag zu löschen
|
||||
}
|
||||
current = current.next; //Node wird wieder eins hochgezählt
|
||||
}
|
||||
}
|
||||
|
||||
public void Ausgabe() { //Ausgabe Methode
|
||||
Node<P> current = this.start; //Neuer Node wird erstellt
|
||||
|
||||
while (current != null) { //solange der Node current ungleich null ist
|
||||
System.out.print(current.wert + " "); //ausgabe
|
||||
current = current.next; //current wird auf den nächsten Node gesetzt
|
||||
}
|
||||
System.out.print("\n"); //ausgabe
|
||||
}
|
||||
|
||||
public int size() { // getter Mehode f¸r grˆfle
|
||||
return this.size;
|
||||
}
|
||||
public Node<P> getStart() { // getter Mehode f¸r Start
|
||||
|
||||
public Node<P> getStart() { // getter Mehode f¸r Start
|
||||
return this.start;
|
||||
}
|
||||
public Set<P> intersection(Set<P> s) {
|
||||
Set<P> result = new Set<P>();
|
||||
Node<P> current = this.start;
|
||||
while(current != null) {
|
||||
if(s.contains(current.wert)) result.add(current.wert);
|
||||
current = current.next;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
public Set<P> union(Set<P> s) {
|
||||
Set<P> result = new Set<P>();
|
||||
Node<P> current = this.start;
|
||||
while(current != null) {
|
||||
current = current.next;
|
||||
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
public Set<P> intersection(Set<P> s) { //Intersection Methode
|
||||
Set<P> result = new Set<P>(); //neuees set "result" wird ertsellt
|
||||
Node<P> current = this.start; //neuer Node current wird erstellet
|
||||
while (current != null) { //solange current ungleich null ist
|
||||
if (s.contains(current.wert)) // wenn sn den wert von current hat
|
||||
result.add(current.wert); //soll am result der wert hinzugefügt werden
|
||||
current = current.next; //current wird wieder hochgezählt
|
||||
}
|
||||
return result; //result wird returned
|
||||
}
|
||||
|
||||
public Set<P> union(Set<P> s) { //Methode schreibt beide werte aus beiden Listen zusammen
|
||||
Node<P> current = this.start; //erstellt erste Liste
|
||||
Node<P> current2 = s.start; //erstellt zweite Liste
|
||||
Set<P> result = new Set<P>(); //erstellt dritte Liste
|
||||
|
||||
result.add(current.wert); //fügt wert hinzu
|
||||
|
||||
for (int i = 0; i < this.size(); i++) { //erste liste wird durchgegangen
|
||||
for (int j = 0; j < s.size(); j++) { //zweite Liste wird durchgegangen
|
||||
if (result.contains(current.wert) == false) { // wenn result bereits den wert enthält wird er nicht
|
||||
// hinzugefügt
|
||||
result.add(current.wert); //füht wert ein
|
||||
}
|
||||
if (result.contains(current2.wert) == false) { // wenn result bereits den wert enthält wird er nicht
|
||||
// hinzugefügt
|
||||
result.add(current2.wert); //fügt wert ein
|
||||
}
|
||||
current2 = current2.next; //zählt auf die nächste variable hoch in der zweiten liste
|
||||
|
||||
}
|
||||
current = current.next; // zählt auf die nächste variable in der ersten liste hoch
|
||||
current2 = s.start; // current der zweiten liste wird zum start der zweiten eingegebenen liste
|
||||
}
|
||||
return result; // gibt result zurück worin die listen gerspeichert sind
|
||||
}
|
||||
|
||||
public Set<P> difference(Set<P> s) { //Methode wird erstellt und difference benannt
|
||||
Node<P> current = this.start; // neue Node "current " erstellt und die werte von start eingefügt
|
||||
Set<P> result = new Set<P>(); //neuer Set " result " wird erstellt
|
||||
|
||||
for (int i = 0; i < this.size(); i++) { //for schleife geht die erste variable durch
|
||||
for (int j = 0; j < s.size(); j++) { //for schleife geht zweite variable durch
|
||||
|
||||
if (s.contains(current.wert) == false) { //wenn s denn jetztigen wert nicht hat
|
||||
result.add(current.wert); //soll an result der jetzige wert hinzugefügt werden
|
||||
}
|
||||
}
|
||||
current = current.next; //zählt weiter
|
||||
|
||||
}
|
||||
return result; //gibt result zutück
|
||||
}
|
||||
public boolean subset(Set<P> s) { //neue Methode "subeset"
|
||||
Node<P> current2 = s.start; //neue Node "current2" wird auf start wert von s gesetzt
|
||||
|
||||
while(current2 != null) { //solange current 2 ungleich null ist
|
||||
if(this.contains(current2.wert) == true) { // wenn this denn jetzigen wert hat
|
||||
current2 = current2.next; //current wird eins weiter gesetzt
|
||||
} else { //sonst
|
||||
return false; // soll falls zurückgegeben werden
|
||||
}
|
||||
}
|
||||
return true; //wenn obere while schleife nicht erfüllt weird soll es true zurückgeben
|
||||
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -1,21 +1,43 @@
|
|||
|
||||
public class SetTest {
|
||||
|
||||
public static void main(String[] args) {
|
||||
Set<Integer> set = new Set<Integer>();
|
||||
Set<Integer> set2 = new Set<Integer>();
|
||||
set.add(1);
|
||||
set.add(2);
|
||||
set.add(3);
|
||||
set.add(4);
|
||||
set2.add(4);
|
||||
set.add(9);
|
||||
set.remove(2);
|
||||
set.isEmpty();
|
||||
|
||||
Set<Integer> I = set.intersection(set2);
|
||||
System.out.println("Groeße " + set.size());
|
||||
set.Ausgabe();
|
||||
Set<Integer> Set = new Set<Integer>();
|
||||
Set<Integer> Set2 = new Set<Integer>();
|
||||
|
||||
Set.add(5);// fügt neue variable der Liste an
|
||||
Set.add(3);// fügt neue variable der Liste an
|
||||
Set.add(2);// fügt neue variable der Liste an
|
||||
Set.add(9);// fügt neue variable der Liste an
|
||||
Set.add(7);// fügt neue variable der Liste an
|
||||
|
||||
Set2.add(3);// fügt neue variable der Liste zweiten Liste an
|
||||
Set2.add(7);// fügt neue variable der Liste zweiten Liste an
|
||||
Set2.add(5);// fügt neue variable der Liste zweiten Liste an
|
||||
Set2.add(6);// fügt neue variable der Liste zweiten Liste an
|
||||
Set2.add(1);// fügt neue variable der Liste zweiten Liste an
|
||||
|
||||
System.out.println(Set.contains(4)); //Ausgabe von Set
|
||||
|
||||
|
||||
System.out.println(Set.isEmpty()); //Ausgabe von Empty Methode
|
||||
|
||||
Set.remove(0); //removed zahl
|
||||
|
||||
System.out.println(Set.subset(Set2)); //Ausgabe von subset
|
||||
Set<Integer> I = Set.intersection(Set2); //Methode intersection wird aufgerufen
|
||||
I.Ausgabe(); //Ausgabe von intersection
|
||||
System.out.println("Union"); //ausgabe
|
||||
Set<Integer> U = Set.union(Set2); //siehe intersection
|
||||
U.Ausgabe();
|
||||
System.out.println("Difference ");
|
||||
Set<Integer> D = Set.difference(Set2);
|
||||
D.Ausgabe();
|
||||
|
||||
System.out.println(Set.size()); //ausgabe von größe
|
||||
|
||||
Set.Ausgabe(); //Ausgabe
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue