merge upstream

Datenstrukturen/BinaererSuchbaum/BinaererSuchbaum.java

@@ -0,0 +1,112 @@
+// Generische Klasse für einen Binären Suchbaum
+class BinaererSuchbaum<T extends Comparable<T>> {
+    // Knoten-Klasse
+    private static class Knoten<T> {
+        T daten;
+        Knoten<T> links, rechts;
+
+        Knoten(T daten) {
+            this.daten = daten;
+            links = rechts = null;
+        }
+    }
+
+    private Knoten<T> wurzel;
+
+    // Methode zum Hinzufügen von Elementen
+    public void hinzufuegen(T wert) {
+        this.wurzel = hinzufuegen(wert, wurzel);    
+    }
+
+    private Knoten<T> hinzufuegen(T wert, Knoten<T> wurzel) {
+        if (wert != null)
+            if (wurzel == null)
+                wurzel = new Knoten<T>(wert);
+            else
+                if (wert.compareTo(wurzel.daten) < 0)
+                    wurzel.links = hinzufuegen(wert, wurzel.links);
+                else if (wert.compareTo(wurzel.daten) > 0)
+                    wurzel.rechts = hinzufuegen(wert, wurzel.rechts);
+
+        return wurzel;
+    }
+
+    // Methode zur Suche eines Elements
+    public T suchen(T wert) {
+        return suchen(wert, wurzel);
+    }
+
+    private T suchen(T wert, Knoten<T> wurzel) {
+        if (wurzel == null || wert == null)
+            return null;
+        else
+            if (wert.compareTo(wurzel.daten) < 0)
+                return suchen(wert, wurzel.links);
+            else if (wert.compareTo(wurzel.daten) > 0)
+                return suchen(wert, wurzel.rechts);
+            else if (wert.compareTo(wurzel.daten) == 0)
+                return wurzel.daten;
+            else
+                return null;
+    }
+
+
+    // Methode zum Löschen eines Elements
+    public void loeschen(T wert) {
+        this.wurzel = loeschen(wert, wurzel);
+    }
+
+    private Knoten<T> loeschen(T wert, Knoten<T> wurzel) {
+        if (wurzel != null && wert != null)
+            if (wert.compareTo(wurzel.daten) < 0)
+                wurzel.links = loeschen(wert, wurzel.links);
+            else if (wert.compareTo(wurzel.daten) > 0)
+                wurzel.rechts = loeschen(wert, wurzel.rechts);
+            else if (wurzel.links == null)
+                if (wurzel.rechts == null)
+                    wurzel = null;
+                else
+                    wurzel = wurzel.rechts;
+            else
+                if (wurzel.rechts == null)
+                    wurzel = wurzel.links;
+                else {
+                    Knoten<T> minInhalt = blattSuchen(wurzel, false);
+                    minInhalt.links = wurzel.links;
+                    wurzel = minInhalt;
+                    wurzel.rechts = loeschen(minInhalt.daten, wurzel.rechts);
+                }
+
+        return wurzel;
+    }
+
+    public Knoten<T> blattSuchen(Knoten<T> wurzel, boolean links) {
+        if (wurzel.daten == null)
+            return null;
+        else
+            if (links)
+                if (wurzel.links == null)
+                    return wurzel;
+                else
+                    return blattSuchen(wurzel.links, links);
+            else
+                if (wurzel.rechts == null)
+                    return wurzel;
+                else
+                    return blattSuchen(wurzel.rechts, links);
+    }
+
+    // Inorder-Traversierung für Ausgabe
+    public void inorderAusgabe() {
+        inorderRekursiv(wurzel);
+        System.out.println();
+    }
+
+    private void inorderRekursiv(Knoten<T> knoten) {
+        if (knoten != null) {
+            inorderRekursiv(knoten.links);
+            System.out.print(knoten.daten + " ");
+            inorderRekursiv(knoten.rechts);
+        }
+    }
+}

Datenstrukturen/BinaererSuchbaum/BinaererSuchbaumDemoSchueler.java

@@ -0,0 +1,61 @@
+import java.util.Scanner;
+
+public class BinaererSuchbaumDemoSchueler {
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        BinaererSuchbaum<Double> baum = new BinaererSuchbaum<>();
+        boolean laeuft = true;
+
+        while (laeuft) {
+            System.out.println("\nBinärer Suchbaum - Menü:");
+            System.out.println("0. Elemente automatisch hinzufügen");
+            System.out.println("1. Element hinzufügen");
+            System.out.println("2. Element suchen");
+            System.out.println("3. Element löschen");
+            System.out.println("4. Baum anzeigen (Inorder-Traversierung)");
+            System.out.println("5. Programm beenden");
+            System.out.print("Wähle eine Option: ");
+
+            int auswahl = scanner.nextInt();
+            double element;
+            switch (auswahl) {
+                case 0:
+                    for (double i = -15; i <= 15; i+=0.5) {
+                        System.out.println("Zu hinzufügendes Element: " + i);
+                        baum.hinzufuegen(i);
+                        System.out.println("Element hinzugefügt.");
+                    }
+                    break;
+                case 1 : 
+                    System.out.print("Zu hinzufügendes Element: ");
+                    element = scanner.nextDouble();
+                    baum.hinzufuegen(element);
+                    System.out.println("Element hinzugefügt.");
+                    break;
+                case 2 : 
+                    System.out.print("Zu suchendes Element: ");
+                    element = scanner.nextDouble();
+                    boolean gefunden = baum.suchen(element) != null;
+                    System.out.println(gefunden ? "Element gefunden." : "Element nicht gefunden.");
+                    break;
+                case 3 : 
+                    System.out.print("Zu löschendes Element: ");
+                    element = scanner.nextDouble();
+                    baum.loeschen(element);
+                    System.out.println("Element gelöscht (falls vorhanden).");
+                    break;
+                case 4 : 
+                    System.out.println("Baum (Inorder-Traversierung):");
+                    baum.inorderAusgabe();
+                    break;
+                case 5 : 
+                    laeuft = false;
+                    System.out.println("Programm wird beendet.");
+                    break;
+                default : System.out.println("Ungültige Auswahl. Bitte versuche es erneut.");  break;
+            }
+        }
+
+        scanner.close();
+    }
+}

Datenstrukturen/Traversierung/Traversierung.java

@@ -0,0 +1,109 @@
+import java.util.LinkedList;
+import java.util.Queue;
+
+public class Traversierung {
+	public static void preOrder(Node knoten) {
+		// 1. Wert des Knotens ausgeben
+		System.out.print(knoten.wert + " ");
+
+		// 2. Rekursiv für linken Teilbaum ausführen
+		if (knoten.links != null)
+			preOrder(knoten.links);
+
+		// 3. Rekursiv für rechten Teilbaum ausführen
+		if (knoten.rechts != null)
+			preOrder(knoten.rechts);
+	}
+
+	public static void inOrder(Node knoten) {
+		// 1. Rekursiv für linken Teilbaum ausführen
+		if (knoten.links != null)
+			inOrder(knoten.links);
+
+		// 2. Wert des Knotens ausgeben
+		System.out.print(knoten.wert + " ");
+
+		// 3. Rekursiv für rechten Teilbaum ausführen
+		if (knoten.rechts != null)
+			inOrder(knoten.rechts);
+	}
+
+	public static void postOrder(Node knoten) {
+		// 1. Rekursiv für linken Teilbaum ausführen
+		if (knoten.links != null)
+			postOrder(knoten.links);
+
+		// 2. Rekursiv für rechten Teilbaum ausführen
+		if (knoten.rechts != null)
+			postOrder(knoten.rechts);
+
+		// 3. Wert des Knotens ausgeben
+		System.out.print(knoten.wert + " ");
+	}
+
+	public static void levelOrder(Node knoten) {
+		// 1. Schlange anlegen
+		Queue<Node> queue = new LinkedList<>();
+
+		// 2. Wurzel zur Schlange hinzufügen
+		queue.add(knoten);
+
+		// 3. Solange die Schlange nicht leer ist...
+		while (!queue.isEmpty()) {
+			// 4. Linken und rechten Kindknoten zur Schlange hinzufügen
+			knoten = queue.peek();
+			if (knoten.links != null) queue.add(knoten.links);
+			if (knoten.rechts != null) queue.add(knoten.rechts);
+			
+			// 5. Wert des Hauptknotens ausgeben
+			System.out.print(knoten.wert + " ");
+			
+			// 6. Hauptknoten aus der Schlange entfernen
+			queue.poll();
+
+			// weiter bei 3....
+		}
+	}
+
+	public static void main(String[] args) {
+		// Beispielbaum aus der PDF-Datei
+		Node wurzel = new Node(3);
+		wurzel.links = new Node(1);
+		wurzel.links.links = new Node(13);
+		wurzel.rechts = new Node(10);
+		wurzel.rechts.links = new Node(11);
+		wurzel.rechts.rechts = new Node(16);
+		wurzel.rechts.rechts.links = new Node(15);
+		wurzel.rechts.rechts.rechts = new Node(2);
+
+		System.out.print("Pre-order: ");
+		preOrder(wurzel);
+		System.out.println();
+		// 3 1 13 10 11 16 15 2
+
+		System.out.print("In-order: ");
+		inOrder(wurzel);
+		System.out.println();
+		// 13 1 3 11 10 15 16 2
+
+		System.out.print("Post-order: ");
+		postOrder(wurzel);
+		System.out.println();
+		// 13 1 11 15 2 16 10 3
+
+		System.out.print("Level-order: ");
+		levelOrder(wurzel);
+		System.out.println();
+		// 3 1 10 13 11 16 15 2
+	}
+}
+
+class Node {
+	int wert;
+	Node links;
+	Node rechts;
+
+	Node(int wert) {
+		this.wert = wert;
+	}
+}

Klassen/Technikladen/TechStore.java

@@ -104,6 +104,8 @@ public class TechStore {
 			}
 			}
 		}
+
+		scnr.close();
 	}
 }