= 24/25 - 3ahitm - sew - Lecture Notes
Thomas W. Stütz
1.0.0, {docdate}: Softwareentwicklung
ifndef::imagesdir[:imagesdir: images]
:icons: font
:experimental:
:sectnums:
:toc:
:toclevels: 5
:experimental:

// https://mrhaki.blogspot.com/2014/06/awesome-asciidoc-use-link-attributes.html
:linkattrs:

ifdef::backend-html5[]
// https://fontawesome.com/v4.7.0/icons/
icon:file-text-o[link=https://raw.githubusercontent.com/2425-3ahitm-sew/2425-3ahitm-sew-lecture-notes/refs/heads/main/asciidocs/docs/{docname}.adoc] ‏ ‏ ‎
icon:github-square[link=https://github.com/2425-3ahitm-sew/2425-3ahitm-sew-lecture-notes] ‏ ‏ ‎
icon:home[link=http://edufs.edu.htl-leonding.ac.at/~t.stuetz/hugo/2021/01/lecture-notes/]
endif::backend-html5[]



== Exkurs: JavaFX-Spinner


A `Spinner` in JavaFX is a UI control that allows users to select a value from a sequence by either typing it or using arrow buttons to increment/decrement the value.

=== Basic Usage

To create a numeric `Spinner`:

[source,java]
----
import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.Spinner;
import javafx.scene.control.SpinnerValueFactory;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;

public class SpinnerExample extends Application {

    @Override
    public void start(Stage stage) {
        // Create a Spinner for numbers
        Spinner<Integer> spinner = new Spinner<>();

        // Set the value factory (range: 1 to 100, initial value: 50, step: 1)
        spinner.setValueFactory(new SpinnerValueFactory.IntegerSpinnerValueFactory(1, 100, 50, 1));

        // Add spinner to the scene
        VBox root = new VBox(10, spinner);
        root.setStyle("-fx-padding: 20; -fx-alignment: center;");

        Scene scene = new Scene(root, 300, 200);
        stage.setScene(scene);
        stage.setTitle("JavaFX Spinner Example");
        stage.show();
    }

    public static void main(String[] args) {
        launch();
    }
}
----

=== Spinner with Strings

A `Spinner` can use a list of values, such as strings:

[source,java]
----
Spinner<String> stringSpinner = new Spinner<>();
SpinnerValueFactory<String> valueFactory =
    new SpinnerValueFactory.ListSpinnerValueFactory<>(FXCollections.observableArrayList("Option 1", "Option 2", "Option 3"));

stringSpinner.setValueFactory(valueFactory);
----

=== Event Handling

You can listen to changes in the spinner’s value using a listener:

[source,java]
----
spinner.valueProperty().addListener((observable, oldValue, newValue) -> {
    System.out.println("Selected Value: " + newValue);
});
----

=== Editable Spinner

By default, a `Spinner` is editable. You can disable editing as follows:

[source,java]
----
spinner.setEditable(false);
----

=== Styling the Spinner

The `Spinner` can be styled using CSS:

[source,css]
----
.spinner {
    -fx-background-color: lightblue;
    -fx-padding: 5;
}
----

To apply the CSS file:
[source,java]
----
scene.getStylesheets().add("style.css");
----

=== Advanced Example: Spinner with Different Step Sizes

You can configure a `Spinner` with specific step sizes:
[source,java]
----
Spinner<Double> doubleSpinner = new Spinner<>();
doubleSpinner.setValueFactory(new SpinnerValueFactory.DoubleSpinnerValueFactory(0.0, 10.0, 5.0, 0.5));
----

=== Common Methods

- `getValue()`: Retrieves the current value of the spinner.
- `setValue()`: Sets a specific value for the spinner.
- `increment(int steps)`: Increases the spinner's value by a specified number of steps.
- `decrement(int steps)`: Decreases the spinner's value by a specified number of steps.

=== References

* JavaFX API Reference: https://openjfx.io/javadoc/23/javafx.controls/javafx/scene/control/Spinner.html[Spinner Documentation]
* JavaFX Tutorials: https://code.makery.ch/library/javafx-tutorial/[CodeMakery JavaFX Tutorials]

IMPORTANT: This content was createt with ChatGPT (Prompt: How to to use spinner in JavaFx)

== 2025-03-25

=== Sockets

.Erstellen des ServerSockets
[source,java]
----
var serverSocket = ServerSocketFactory
                .getDefault()
                .createServerSocket(8080);
----

. Handler für einkommende Requests (ClientSocket)
[source,java]
----
Socket clientSocket = serverSocket.accept();
handleConnect(clientSocket);
----

. Streams für Input und Output
[source,java]
----
var outputStream = clientSocket.getOutputStream();
var inputStream = clientSocket.getInputStream();
----

== 2025-05-26

=== Übung

* Erstellen Sie eine Liste der Klasse mit Vor- und Nachnamen sowie der PLZ

* Nun erstellen Sie für Vor- und Nachnamen sowie die PLZT jeweils einen binären Suchbaum. Als Datenelement verwenden Sie den Index der einzelnen Elemente (Personen) in der Liste

* Bei gleichen Elementen in Personen (zB PLZ 4060) werden als Ergebnis mehrere Personen ausgegeben

* Bei jedem Zugriff ist die Anzahl der Vergleichvorgänge im Baum auszugeben.

* Der Baum ist grafisch darzustellen bspw als JavaFx Baumelement oder auf einem Canvas oder auch in plantuml (https://plantuml.com/de/mindmap-diagram)

* Erweiterung

** Wird die Liste mit Personen geändert, sind natürlich sämtliche Suchbäume zu aktualisieren.

** Implementieren Sie die Ausgabe in preorder, postorder, levelorder, inorder


=== Bäume

++++
<iframe width="560" height="315" src="https://www.youtube.com/embed/Etpc_-br5rI?si=ZDvpNxZuLmAo6J3C" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>
++++

Rang eines Baumes:: Anzahl seiner direkten Nachfolger
Ordnung des Baumes:: Maximaler Rang seiner Knoten
Traversierung:: Systematisches Durchlaufen von Datenstrukturen wie Bäume, Arrays oder Listen



++++
<iframe width="560" height="315" src="https://www.youtube.com/embed/b_NjndniOqY?si=HVb7tR0Qe-zg6zTc" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>
++++
Rekursion:: Rekursion ist eine Technik, bei der sich eine Methode selbst aufruft, um ein Problem zu lösen. Dabei wird ein großes Problem in kleinere Teilprobleme zerlegt – bis zu einem Abbruchpunkt (Abbruchbedingung).

==== Baumtraversierungen

* preorder
** zuerst die Wurzel
** dann linken Teilbaum
** zuletzt rechten Teilbaum

* inorder
** zuerst linken Teilbaum
** dann die Wurzel
** zuletzt rechten Teilbaum

* postorder
** zuerst linken Teilbaum
** dann rechten Teilbaum
** zuletzt die Wurzel

* levelorder (Breitensuche)
** Ebene für Ebene von oben nach unten
** innerhalb jeder Ebene von links nach rechts

[plantuml]
----
@startuml
!define RECTANGLE class

RECTANGLE 4 {
}

RECTANGLE 2 {
}

RECTANGLE 5 {
}

RECTANGLE 1 {
}

RECTANGLE 3 {
}

4 -down-> 2
4 -down-> 5
2 -down-> 1
2 -down-> 3

note right of 4
Traversierungen:
Preorder: 4, 2, 1, 3, 5
Inorder: 1, 2, 3, 4, 5
Postorder: 1, 3, 2, 5, 4
Levelorder: 4, 2, 5, 1, 3
end note
@enduml
----

==== Spezielle Bäume
* Binärbaum
** Jeder Knoten hat maximal 2 Nachfolger
* Balancierter Baum
** AVL Baum

* Vollständiger Baum
** Ein vollständiger Baum ist ein Binärbaum, bei dem alle Ebenen vollständig gefüllt sind, außer ggf. der letzten die von link nach rechts gefüllt ist.
** Unterste Ebene ist von links beginnend gefüllt
** Höhere Ebenen sind gänzlich gefüllt


==== Binärer Suchbaum
* Ein binärer Suchbaum ist eine Binärbaum mit Ordnungsrelation.

* Aufgaben
** Suchen im binären Suchbaum
** Einfügen im binären Suchbaum
** Löschen im binären Suchbaum