FLBK-Wiki - Benutzerbeiträge [de]

Eingaben für Klausuren auf eLearning

2026-11-04T06:38:08Z

Flbkwikiadmin:

Mathematische Zeichen für die Verwendung in Klausuren über elearning.flbk-hamm.de werden wie folgt eingegeben:

{| class="wikitable"

! Eingabe !! Darstellung

|-

| 2*x^3 || <math>2 \cdot x^3</math>

|-

| sqrt(5) || <math>\sqrt{5}</math>

|-

| 2/3 || <math>\frac{2}{3}</math>

|-

| x=-(p/2)+-sqrt((p/2)^2-q) || <math>x=- \frac{p}{2} \pm \sqrt{(\frac{p}{2})^2-q}</math>

|-

| x=3 or x=5 || <math>x_1=3 \lor x_2=5</math>

|-

| x=3 and x=5 || <math>x_1=3 \land x_2=5</math>

|-

| +- || <math>\pm </math>

|-

| binomial(n;k) || <math>\binom{n}{k}</math>

|-

| int(x^2-1;x;1;5) || <math>\int_{1}^{5}(x^2-1)dx</math>

|-

| p[N] || <math>p_N</math>

|-

| STRG + X || Ausschneiden

|-

| STRG + C || Kopieren

|-

| STRG + V || Einfügen

|-

| STRG + + oder STRG + Mausrad Hoch || Vergrößern

|-

| STRG + - oder STRG + Mausrad Runter || Verkleinern

|-

| STRG + A || Alles markieren

|-

| Umschalttaste + Pfeil || Stückweise markieren

|}

[[Kategorie:Mathematik]]

Eingaben für Klausuren auf eLearning

2026-11-04T06:36:21Z

Flbkwikiadmin:

Mathematische Zeichen und Ausdrücke für die Eingabe in Klausuren und Übungen über [[Moodle]] (elearning.flbk-hamm.de) mit STACK-Aufgaben werden wie folgt eingegeben.

Da das deutsche Zahlenformat aktiv ist, werden Dezimalzahlen mit Komma geschrieben (z. B. <code>3,5</code>) und Funktionsargumente, Listen sowie Mengen '''zwingend mit einem Semikolon (<code>;</code>)''' getrennt.

== Grundrechenarten, Potenzen und Brüche ==
{| class="wikitable"
! Mathematischer Ausdruck !! Eingabe in Moodle !! Erzeugte Darstellung !! Wichtiger Hinweis
|-
| Multiplikation (Malzeichen) || <code>2*x^3</code> || <math>2 \cdot x^3</math> || Das Malzeichen <code>*</code> darf nie weggelassen werden (nicht <code>2x</code> schreiben).
|-
| Dezimalzahl || <code>3,5</code> || <math>3{,}5</math> || Reguläres Komma verwenden.
|-
| Bruch || <code>2/3</code> || <math>\frac{2}{3}</math> || Geteilt-Zeichen <code>/</code>
|-
| Zusammengesetzter Bruch || <code>(x+1)/(x-2)</code> || <math>\frac{x+1}{x-2}</math> || Zähler und Nenner stets in Klammern setzen.
|-
| Potenz || <code>x^3</code> || <math>x^3</math> || Zirkumflex <code>^</code>
|-
| Potenz mit Term im Exponenten || <code>e^(2*x)</code> || <math>e^{2x}</math> || Den gesamten Exponenten klammern.
|-
| Index (Tiefstellung) || <code>p[N]</code> oder <code>x[1]</code> || <math>p_N</math> bzw. <math>x_1</math> || Eckige Klammern für Indizes.
|}

== Mathematische Funktionen und Konstanten ==
{| class="wikitable"
! Funktion / Konstante !! Eingabe in Moodle !! Erzeugte Darstellung !! Wichtiger Hinweis
|-
| Quadratwurzel || <code>sqrt(5)</code> || <math>\sqrt{5}</math> || <code>sqrt(...)</code> für ''square root''.
|-
| Höhere Wurzel (z. B. 3. Wurzel) || <code>x^(1/3)</code> || <math>\sqrt[3]{x}</math> || Exponent als Bruch klammern.
|-
| Plus-Minus-Zeichen || <code>+-</code> || <math>\pm</math> || Als Operator direkt eingebbar.
|-
| Exponentialfunktion || <code>exp(x)</code> || <math>e^x</math> || Alternativ <code>%e^x</code>.
|-
| Natürlicher Logarithmus || <code>ln(x)</code> || <math>\ln(x)</math> ||
|-
| Betrag || <code>abs(x)</code> || <math>|x|</math> ||
|-
| Kreiszahl Pi (<math>\pi</math>) || <code>pi</code> || <math>\pi</math> || Kleinbuchstaben eingeben.
|-
| Binomialkoeffizient <math>\binom{n}{k}</math> || <code>binomial(5;2)</code> || <math>\binom{5}{2}</math> || Trennung zwingend mit Semikolon <code>;</code>.
|-
| Bestimmtes Integral || <code>int(x^2-1;x;1;5)</code> || <math>\int_{1}^{5} (x^2-1) \, dx</math> || Syntax: <code>int(Term; Variable; Untergrenze; Obergrenze)</code>
|-
| Unbestimmtes Integral || <code>int(x^2-1;x)</code> || <math>\int (x^2-1) \, dx</math> || Syntax: <code>int(Term; Variable)</code>
|}

== Gleichungen, Bedingungen und Mengen ==
{| class="wikitable"
! Ausdruck !! Eingabe in Moodle !! Erzeugte Darstellung !! Wichtiger Hinweis
|-
| Gleichung mit pq-Formel || <code>x = -(p/2)+-sqrt((p/2)^2-q)</code> || <math>x = -\frac{p}{2} \pm \sqrt{\left(\frac{p}{2}\right)^2-q}</math> || <code>+-</code> verbindet beide Lösungen in einem Term.
|-
| Logisches ODER (z. B. Einzellösungen) || <code>x=3 or x=5</code> || <math>x=3 \lor x=5</math> || Trennung alternativer Lösungen.
|-
| Logisches UND (z. B. Intervalle) || <code>x>=1 and x<=5</code> || <math>x \ge 1 \land x \le 5</math> || Kleiner/Größer-Gleich als <code><=</code> bzw. <code>>=</code>.
|-
| Lösungsmenge || <code>{3; 5}</code> || <math>\{3; 5\}</math> || Geschweifte Klammern, Trennung mit Semikolon <code>;</code>.
|-
| Intervall || <code>[1; 5]</code> || <math>[1; 5]</math> || Trennung der Intervallgrenzen mit Semikolon <code>;</code>.
|}

== Tastenkombinationen für Klausuren ==
{| class="wikitable"
! Tastenkombination !! Funktion
|-
| {{Taste|Strg}} + {{Taste|C}} || Kopieren
|-
| {{Taste|Strg}} + {{Taste|V}} || Einfügen
|-
| {{Taste|Strg}} + {{Taste|X}} || Ausschneiden
|-
| {{Taste|Strg}} + {{Taste|Z}} || Letzte Eingabe rückgängig machen
|-
| {{Taste|Strg}} + {{Taste|A}} || Alles markieren
|-
| {{Taste|Umschalt}} + {{Taste|Pfeiltaste}} || Text stückweise markieren
|-
| {{Taste|Strg}} + {{Taste|+}} oder {{Taste|Strg}} + Mausrad nach oben || Schrift / Darstellung vergrößern
|-
| {{Taste|Strg}} + {{Taste|-}} oder {{Taste|Strg}} + Mausrad nach unten || Schrift / Darstellung verkleinern
|-
| {{Taste|Strg}} + {{Taste|0}} || Zoomfaktor auf Standard (100 %) zurücksetzen
|}

[[Kategorie:Mathematik]]
[[Kategorie:AHR WuV Mathe GK]]
[[Kategorie:FHR WuV Mathe]]

DDL

2026-10-15T07:10:00Z

Flbkwikiadmin:

== Einstieg ==
Die '''Data Definition Language''' (kurz '''DDL''') ist ein fundamentaler Bestandteil von [[SQL]]. Die DDL wird eingesetzt, um das Datenschema in relationalen [[Datenbank]]en zu beschreiben, zu ändern oder zu entfernen. Das Erstellen von Tabellen mit Hilfe der DDL ist in der Regel der letzte strukturelle Schritt im Datenbankentwicklungsprozess, bevor Daten eingefügt werden können.
[[Datei:ERM-Softwarentwicklungsprozess.png|mini|Einordnung im Softwareentwicklungsprozess]]
[[Datei:DBMS-MySQL.png|mini|Darstellung in der MySQL-Workbench]]
[[Datei:Schlüssel-SchlüsselInTabellen.png|mini|Schlüsselbeziehungen in Tabellen]]

== CREATE SCHEMA ==
Alle Datenbank-Tabellen befinden sich in einem Schema. Dieses Schema repräsentiert die Datenbank an sich. Bevor Tabellen angelegt werden können, muss ein Schema vorhanden sein.

'''Syntax:'''
<syntaxhighlight lang="sql">
CREATE SCHEMA <Schema-Name>;
</syntaxhighlight>

'''Beispiel:'''
<syntaxhighlight lang="sql">
CREATE SCHEMA friseur;
</syntaxhighlight>

In einem Datenbankmanagementsystem (DBMS) können mehrere Schemata verwaltet werden. Daher ist sicherzustellen, dass sich alle Anweisungen der SQL eindeutig auf ein Schema beziehen lassen, damit das DBMS die angesprochenen Tabellen identifizieren kann. Der Bezug zu einem Schema ergibt sich aus der Punktnotation:
<code>Schemaname.Tabellenname</code>

Das Schema <code>friseur</code> verwaltet alle Salons. Eine Tabelle <code>salon</code> lässt sich also über <code>friseur.salon</code> ansprechen.

== CREATE TABLE ==
Tabellen stellen die Grundstruktur für die Speicherung von Daten in der Datenbank dar.

'''Syntax:'''
<syntaxhighlight lang="sql">
CREATE TABLE <Tabellen_Name> (
<Spalte 1> <Datentyp_für_Spalte_1>,
<Spalte 2> <Datentyp_für_Spalte_2>,
...
);
</syntaxhighlight>

'''Beispiele:'''
Zur Erstellung einer einfachen Mitarbeitertabelle:
<syntaxhighlight lang="sql">
CREATE TABLE mitarbeiter (
idmitarbeiter INT,
nachname VARCHAR(45),
vorname VARCHAR(45)
);
</syntaxhighlight>

Zur Erstellung einer simplen Salontabelle:
<syntaxhighlight lang="sql">
CREATE TABLE salon (
idsalon INT,
name VARCHAR(45)
);
</syntaxhighlight>

== CONSTRAINTs (Einschränkungen) ==
CONSTRAINT heißt übersetzt „Zwang“ oder „Einschränkung“. Ein CONSTRAINT ist eine Bedingung, der ein Datensatz zwingend entsprechen muss. Wenn eine der aktuell gültigen Bedingungen verletzt wird, wird der betreffende Datensatz nicht gespeichert. Hierdurch wird die '''Datenkonsistenz''' gewährleistet.

Die Befehle <code>PRIMARY KEY</code>, <code>FOREIGN KEY</code>, <code>NOT NULL</code> und <code>UNIQUE</code> fallen in die Kategorie CONSTRAINT. Nach der Attributliste wird das Schlüsselwort <code>CONSTRAINT</code> gesetzt (wobei das Wort <code>CONSTRAINT</code> selbst oft optional ist, wenn man die Standardnamen des DBMS akzeptiert).

=== Primärschlüssel (PRIMARY KEY) ===
Es gibt drei Varianten, um die Entitätsintegrität (Eindeutigkeit) mit Hilfe eines [[Schlüssel|Primärschlüssels]] zu definieren:

1. '''Am Ende der Attributliste:'''
<syntaxhighlight lang="sql">
CREATE TABLE mitarbeiter (
idmitarbeiter INT,
nachname VARCHAR(45),
vorname VARCHAR(45),
PRIMARY KEY (idmitarbeiter)
);
</syntaxhighlight>

2. '''Direkt in der Spaltendefinition:'''
<syntaxhighlight lang="sql">
CREATE TABLE mitarbeiter (
idmitarbeiter INT PRIMARY KEY,
nachname VARCHAR(45),
vorname VARCHAR(45)
);
</syntaxhighlight>

3. '''Mit explizitem CONSTRAINT-Namen:''' (Im Beispiel „pk“ für primary key)
<syntaxhighlight lang="sql">
CREATE TABLE mitarbeiter (
idmitarbeiter INT,
nachname VARCHAR(45),
vorname VARCHAR(45),
fksalon INT,
CONSTRAINT pk PRIMARY KEY (idmitarbeiter)
);
</syntaxhighlight>

=== Fremdschlüssel (FOREIGN KEY) ===
Mit einem [[Schlüssel|Fremdschlüssel]] wird eine Spalte der einen Tabelle mit einer gleichartigen Spalte einer anderen Tabelle (meist dem Primärschlüssel) verknüpft, um referenzielle Integrität sicherzustellen. Beide Spalten müssen den exakt gleichen Datentyp besitzen.

:'''Wichtig:''' Die referenzierte Tabelle (hier <code>salon</code>) muss bereits existieren, bevor der Fremdschlüssel in der referenzierenden Tabelle (<code>mitarbeiter</code>) angelegt werden kann.

<syntaxhighlight lang="sql">
CREATE TABLE mitarbeiter (
idmitarbeiter INT,
nachname VARCHAR(45),
vorname VARCHAR(45),
fksalon INT,
CONSTRAINT pk PRIMARY KEY (idmitarbeiter),
CONSTRAINT fk FOREIGN KEY (fksalon) REFERENCES salon(idsalon)
);
</syntaxhighlight>

==== FOREIGN KEY Optionen (Referenzielle Aktionen) ====
Diese Optionen bestimmen das Verhalten der Detailtabelle, wenn in der Primärtabelle Datensätze geändert (<code>ON UPDATE</code>) oder gelöscht (<code>ON DELETE</code>) werden:

* '''NO ACTION / RESTRICT''': Die Änderung oder Löschung in der Primärtabelle wird verweigert und mit einem Fehler abgebrochen, falls abhängige Datensätze existieren.
* '''CASCADE''': Die Änderung (z. B. eine neue ID) oder die Löschung wird „kaskadierend“ an die Detailtabelle weitergegeben. Löscht man den Salon, werden alle Mitarbeiter dieses Salons ebenfalls gelöscht.
* '''SET NULL''': Wird der Primärschlüssel gelöscht oder geändert, wird der Fremdschlüssel in der Detailtabelle auf <code>NULL</code> gesetzt (nur möglich, wenn die Spalte nicht als <code>NOT NULL</code> definiert ist).

=== NOT NULL ===
Die Schlüsselwörter <code>NULL</code> bzw. <code>NOT NULL</code> legen fest, ob leere Werte in der Spalte zulässig sind. Der Standardwert ist „zulässig“ (<code>NULL</code>). Primärschlüssel sollten grundsätzlich als <code>NOT NULL</code> deklariert werden.

=== AUTO_INCREMENT / AUTOINCREMENT ===
Dieses Schlüsselwort legt fest, dass die Werte in der Spalte automatisch vom DBMS hochgezählt werden (z. B. für IDs).
* '''In MySQL:''' <code>idSalon INT AUTO_INCREMENT</code>
* '''In MS Access:''' <code>idSalon AUTOINCREMENT</code> (wird hier wie ein eigener Datentyp behandelt).

=== DEFAULT ===
Legt einen Standardwert fest, der eingesetzt wird, wenn bei einem neuen Datensatz kein Wert für diese Spalte übergeben wird. (Achtung: Wird in MS Access in reinem DDL oft nicht nativ unterstützt).
<syntaxhighlight lang="sql">
fksalon INT NOT NULL DEFAULT 1
</syntaxhighlight>

=== UNIQUE ===
Sorgt dafür, dass innerhalb einer Spalte (oder Spaltenkombination) kein Wert doppelt auftreten darf.

'''Komplexes Beispiel (Zusammenführung aller Constraints):'''
<syntaxhighlight lang="sql">
CREATE TABLE mitarbeiter (
idmitarbeiter INT NOT NULL AUTO_INCREMENT,
nachname VARCHAR(45),
vorname VARCHAR(45),
fksalon INT NOT NULL DEFAULT 1,
CONSTRAINT pk_mitarbeiter PRIMARY KEY (idmitarbeiter),
CONSTRAINT fk_salon FOREIGN KEY (fksalon) REFERENCES salon(idsalon),
CONSTRAINT uq_nachname UNIQUE (nachname)
);
</syntaxhighlight>

== ALTER TABLE ==
<code>ALTER TABLE</code> ermöglicht das nachträgliche Ändern der Struktur einer vorhandenen Tabelle.

Mögliche Änderungsoperatoren sind:
* '''ADD''': Spalten/Constraints hinzufügen.
* '''DROP''': Spalten/Constraints entfernen.
* '''MODIFY / ALTER COLUMN''': Datentypen ändern.
* '''RENAME''': Umbenennen.

'''Beispiele:'''
Tabelle umbenennen:
<syntaxhighlight lang="sql">
ALTER TABLE Salon RENAME TO Filiale;
</syntaxhighlight>

Neue Spalte hinzufügen:
<syntaxhighlight lang="sql">
ALTER TABLE Mitarbeiter ADD (istWeiblich BOOLEAN);
</syntaxhighlight>

== DROP TABLE ==
Löscht eine vollständige Tabelle inklusive aller darin enthaltenen Daten unwiderruflich aus der Datenbank.
<syntaxhighlight lang="sql">
DROP TABLE <Tabellen_Name>;
</syntaxhighlight>

== CREATE VIEW ==
Abfragen (DQL) können als sogenannte '''Views''' (Sichten/virtuelle Tabellen) in der Datenbank gespeichert werden. Sie verhalten sich bei Abfragen wie echte Tabellen, speichern aber keine eigenen Daten, sondern führen die hinterlegte <code>SELECT</code>-Abfrage bei jedem Aufruf dynamisch aus.

'''Syntax:'''
<syntaxhighlight lang="sql">
CREATE VIEW <View-Name> AS <Select-Ausdruck>;
</syntaxhighlight>

'''Beispiel:'''
<syntaxhighlight lang="sql">
CREATE VIEW weiblicheMitarbeiter AS
SELECT vorname, nachname
FROM mitarbeiter
WHERE istWeiblich = TRUE;
</syntaxhighlight>

[[Kategorie:Datenbanken]]
[[Kategorie:SQL]]
[[Kategorie:AHR WuV WI GK]]
[[Kategorie:AHR I Informatik LK]]
[[Kategorie:FI I SDM]]

DDL

2026-10-15T07:09:33Z

Flbkwikiadmin:

== Einstieg ==
Die '''Data Definition Language''' (kurz '''DDL''') ist ein fundamentaler Bestandteil von [[SQL]]. Die DDL wird eingesetzt, um das Datenschema in relationalen [[Datenbanken]] zu beschreiben, zu ändern oder zu entfernen. Das Erstellen von Tabellen mit Hilfe der DDL ist in der Regel der letzte strukturelle Schritt im Datenbankentwicklungsprozess, bevor Daten eingefügt werden können.
[[Datei:ERM-Softwarentwicklungsprozess.png|mini|Einordnung im Softwareentwicklungsprozess]]
[[Datei:DBMS-MySQL.png|mini|Darstellung in der MySQL-Workbench]]
[[Datei:Schlüssel-SchlüsselInTabellen.png|mini|Schlüsselbeziehungen in Tabellen]]

== CREATE SCHEMA ==
Alle Datenbank-Tabellen befinden sich in einem Schema. Dieses Schema repräsentiert die Datenbank an sich. Bevor Tabellen angelegt werden können, muss ein Schema vorhanden sein.

'''Syntax:'''
<syntaxhighlight lang="sql">
CREATE SCHEMA <Schema-Name>;
</syntaxhighlight>

'''Beispiel:'''
<syntaxhighlight lang="sql">
CREATE SCHEMA friseur;
</syntaxhighlight>

In einem Datenbankmanagementsystem (DBMS) können mehrere Schemata verwaltet werden. Daher ist sicherzustellen, dass sich alle Anweisungen der SQL eindeutig auf ein Schema beziehen lassen, damit das DBMS die angesprochenen Tabellen identifizieren kann. Der Bezug zu einem Schema ergibt sich aus der Punktnotation:
<code>Schemaname.Tabellenname</code>

Das Schema <code>friseur</code> verwaltet alle Salons. Eine Tabelle <code>salon</code> lässt sich also über <code>friseur.salon</code> ansprechen.

== CREATE TABLE ==
Tabellen stellen die Grundstruktur für die Speicherung von Daten in der Datenbank dar.

'''Syntax:'''
<syntaxhighlight lang="sql">
CREATE TABLE <Tabellen_Name> (
<Spalte 1> <Datentyp_für_Spalte_1>,
<Spalte 2> <Datentyp_für_Spalte_2>,
...
);
</syntaxhighlight>

'''Beispiele:'''
Zur Erstellung einer einfachen Mitarbeitertabelle:
<syntaxhighlight lang="sql">
CREATE TABLE mitarbeiter (
idmitarbeiter INT,
nachname VARCHAR(45),
vorname VARCHAR(45)
);
</syntaxhighlight>

Zur Erstellung einer simplen Salontabelle:
<syntaxhighlight lang="sql">
CREATE TABLE salon (
idsalon INT,
name VARCHAR(45)
);
</syntaxhighlight>

== CONSTRAINTs (Einschränkungen) ==
CONSTRAINT heißt übersetzt „Zwang“ oder „Einschränkung“. Ein CONSTRAINT ist eine Bedingung, der ein Datensatz zwingend entsprechen muss. Wenn eine der aktuell gültigen Bedingungen verletzt wird, wird der betreffende Datensatz nicht gespeichert. Hierdurch wird die '''Datenkonsistenz''' gewährleistet.

Die Befehle <code>PRIMARY KEY</code>, <code>FOREIGN KEY</code>, <code>NOT NULL</code> und <code>UNIQUE</code> fallen in die Kategorie CONSTRAINT. Nach der Attributliste wird das Schlüsselwort <code>CONSTRAINT</code> gesetzt (wobei das Wort <code>CONSTRAINT</code> selbst oft optional ist, wenn man die Standardnamen des DBMS akzeptiert).

=== Primärschlüssel (PRIMARY KEY) ===
Es gibt drei Varianten, um die Entitätsintegrität (Eindeutigkeit) mit Hilfe eines [[Schlüssel|Primärschlüssels]] zu definieren:

1. '''Am Ende der Attributliste:'''
<syntaxhighlight lang="sql">
CREATE TABLE mitarbeiter (
idmitarbeiter INT,
nachname VARCHAR(45),
vorname VARCHAR(45),
PRIMARY KEY (idmitarbeiter)
);
</syntaxhighlight>

2. '''Direkt in der Spaltendefinition:'''
<syntaxhighlight lang="sql">
CREATE TABLE mitarbeiter (
idmitarbeiter INT PRIMARY KEY,
nachname VARCHAR(45),
vorname VARCHAR(45)
);
</syntaxhighlight>

3. '''Mit explizitem CONSTRAINT-Namen:''' (Im Beispiel „pk“ für primary key)
<syntaxhighlight lang="sql">
CREATE TABLE mitarbeiter (
idmitarbeiter INT,
nachname VARCHAR(45),
vorname VARCHAR(45),
fksalon INT,
CONSTRAINT pk PRIMARY KEY (idmitarbeiter)
);
</syntaxhighlight>

=== Fremdschlüssel (FOREIGN KEY) ===
Mit einem [[Schlüssel|Fremdschlüssel]] wird eine Spalte der einen Tabelle mit einer gleichartigen Spalte einer anderen Tabelle (meist dem Primärschlüssel) verknüpft, um referenzielle Integrität sicherzustellen. Beide Spalten müssen den exakt gleichen Datentyp besitzen.

:'''Wichtig:''' Die referenzierte Tabelle (hier <code>salon</code>) muss bereits existieren, bevor der Fremdschlüssel in der referenzierenden Tabelle (<code>mitarbeiter</code>) angelegt werden kann.

<syntaxhighlight lang="sql">
CREATE TABLE mitarbeiter (
idmitarbeiter INT,
nachname VARCHAR(45),
vorname VARCHAR(45),
fksalon INT,
CONSTRAINT pk PRIMARY KEY (idmitarbeiter),
CONSTRAINT fk FOREIGN KEY (fksalon) REFERENCES salon(idsalon)
);
</syntaxhighlight>

==== FOREIGN KEY Optionen (Referenzielle Aktionen) ====
Diese Optionen bestimmen das Verhalten der Detailtabelle, wenn in der Primärtabelle Datensätze geändert (<code>ON UPDATE</code>) oder gelöscht (<code>ON DELETE</code>) werden:

* '''NO ACTION / RESTRICT''': Die Änderung oder Löschung in der Primärtabelle wird verweigert und mit einem Fehler abgebrochen, falls abhängige Datensätze existieren.
* '''CASCADE''': Die Änderung (z. B. eine neue ID) oder die Löschung wird „kaskadierend“ an die Detailtabelle weitergegeben. Löscht man den Salon, werden alle Mitarbeiter dieses Salons ebenfalls gelöscht.
* '''SET NULL''': Wird der Primärschlüssel gelöscht oder geändert, wird der Fremdschlüssel in der Detailtabelle auf <code>NULL</code> gesetzt (nur möglich, wenn die Spalte nicht als <code>NOT NULL</code> definiert ist).

=== NOT NULL ===
Die Schlüsselwörter <code>NULL</code> bzw. <code>NOT NULL</code> legen fest, ob leere Werte in der Spalte zulässig sind. Der Standardwert ist „zulässig“ (<code>NULL</code>). Primärschlüssel sollten grundsätzlich als <code>NOT NULL</code> deklariert werden.

=== AUTO_INCREMENT / AUTOINCREMENT ===
Dieses Schlüsselwort legt fest, dass die Werte in der Spalte automatisch vom DBMS hochgezählt werden (z. B. für IDs).
* '''In MySQL:''' <code>idSalon INT AUTO_INCREMENT</code>
* '''In MS Access:''' <code>idSalon AUTOINCREMENT</code> (wird hier wie ein eigener Datentyp behandelt).

=== DEFAULT ===
Legt einen Standardwert fest, der eingesetzt wird, wenn bei einem neuen Datensatz kein Wert für diese Spalte übergeben wird. (Achtung: Wird in MS Access in reinem DDL oft nicht nativ unterstützt).
<syntaxhighlight lang="sql">
fksalon INT NOT NULL DEFAULT 1
</syntaxhighlight>

=== UNIQUE ===
Sorgt dafür, dass innerhalb einer Spalte (oder Spaltenkombination) kein Wert doppelt auftreten darf.

'''Komplexes Beispiel (Zusammenführung aller Constraints):'''
<syntaxhighlight lang="sql">
CREATE TABLE mitarbeiter (
idmitarbeiter INT NOT NULL AUTO_INCREMENT,
nachname VARCHAR(45),
vorname VARCHAR(45),
fksalon INT NOT NULL DEFAULT 1,
CONSTRAINT pk_mitarbeiter PRIMARY KEY (idmitarbeiter),
CONSTRAINT fk_salon FOREIGN KEY (fksalon) REFERENCES salon(idsalon),
CONSTRAINT uq_nachname UNIQUE (nachname)
);
</syntaxhighlight>

== ALTER TABLE ==
<code>ALTER TABLE</code> ermöglicht das nachträgliche Ändern der Struktur einer vorhandenen Tabelle.

Mögliche Änderungsoperatoren sind:
* '''ADD''': Spalten/Constraints hinzufügen.
* '''DROP''': Spalten/Constraints entfernen.
* '''MODIFY / ALTER COLUMN''': Datentypen ändern.
* '''RENAME''': Umbenennen.

'''Beispiele:'''
Tabelle umbenennen:
<syntaxhighlight lang="sql">
ALTER TABLE Salon RENAME TO Filiale;
</syntaxhighlight>

Neue Spalte hinzufügen:
<syntaxhighlight lang="sql">
ALTER TABLE Mitarbeiter ADD (istWeiblich BOOLEAN);
</syntaxhighlight>

== DROP TABLE ==
Löscht eine vollständige Tabelle inklusive aller darin enthaltenen Daten unwiderruflich aus der Datenbank.
<syntaxhighlight lang="sql">
DROP TABLE <Tabellen_Name>;
</syntaxhighlight>

== CREATE VIEW ==
Abfragen (DQL) können als sogenannte '''Views''' (Sichten/virtuelle Tabellen) in der Datenbank gespeichert werden. Sie verhalten sich bei Abfragen wie echte Tabellen, speichern aber keine eigenen Daten, sondern führen die hinterlegte <code>SELECT</code>-Abfrage bei jedem Aufruf dynamisch aus.

'''Syntax:'''
<syntaxhighlight lang="sql">
CREATE VIEW <View-Name> AS <Select-Ausdruck>;
</syntaxhighlight>

'''Beispiel:'''
<syntaxhighlight lang="sql">
CREATE VIEW weiblicheMitarbeiter AS
SELECT vorname, nachname
FROM mitarbeiter
WHERE istWeiblich = TRUE;
</syntaxhighlight>

[[Kategorie:Datenbanken]]
[[Kategorie:SQL]]
[[Kategorie:AHR WuV WI GK]]
[[Kategorie:AHR I Informatik LK]]
[[Kategorie:FI I SDM]]

Entscheidungsbaum

2026-10-08T14:35:49Z

Flbkwikiadmin:

{{DISPLAYTITLE:Entscheidungsbaum}}

Ein '''Entscheidungsbaum''' ist ein hierarchisches, baumartiges Entscheidungsunterstützungswerkzeug, das Entscheidungen und ihre möglichen Konsequenzen, einschließlich zufälliger Ereignisergebnisse, Ressourcenkosten und Nutzens, visuell und analytisch darstellt. Er wird sowohl im allgemeinen Kontext der Entscheidungsfindung als auch als eine der fundamentalen Methoden im [[Maschinelles_lernen | Maschinelles Lernen]] eingesetzt.

== Grundlagen ==

Im Kern besteht ein Entscheidungsbaum aus folgenden Elementen:

* '''Wurzelknoten (Root Node):''' Der oberste Knoten, der die anfängliche Entscheidung oder Frage repräsentiert.
* '''Innere Knoten (Internal Nodes):''' Knoten, die eine zu treffende Entscheidung oder einen zu testenden Attributwert darstellen. Von jedem inneren Knoten gehen Äste aus.
* '''Äste (Branches):''' Verbindungen zwischen den Knoten, die mögliche Optionen oder die Ergebnisse eines Tests repräsentieren.
* '''Blattknoten (Leaf Nodes):''' Endknoten, die das Ergebnis einer Entscheidungssequenz oder die vorhergesagte Klasse/den vorhergesagten Wert darstellen.

Die Struktur eines Entscheidungsbaums ermöglicht es, komplexe Entscheidungsprozesse in eine Reihe einfacherer, sequenzieller Entscheidungen zu zerlegen.

== Baumdiagramme im Allgemeinen ==

Entscheidungsbäume sind eine spezielle Form von [[Baumdiagramm]]. Im Allgemeinen dienen Baumdiagramme dazu, hierarchische Strukturen oder Prozesse visuell darzustellen. Sie bestehen aus Knoten, die durch Kanten verbunden sind, wobei ein einzelner Wurzelknoten den Ausgangspunkt darstellt.

Anwendungsbereiche von allgemeinen Baumdiagrammen umfassen:

* '''Organigramme:''' Darstellung der Struktur einer Organisation.
* '''Stammbäume:''' Visualisierung von familiären Beziehungen.
* '''Ablaufdiagramme:''' Darstellung von Schritten in einem Prozess.
* '''Klassifikationssysteme:''' Hierarchische Einordnung von Objekten oder Konzepten.

Gemeinsam ist allen Baumdiagrammen die hierarchische Struktur und die Darstellung von Beziehungen zwischen Elementen. Entscheidungsbäume erweitern dieses Konzept um Entscheidungspunkte und mögliche Konsequenzen.

== Entscheidungsbäume im Maschinellen Lernen ==

Im [[Maschinelles_lernen | Maschinelles Lernen]] werden Entscheidungsbäume als [[Supervised Learning|überwachte Lernverfahren]] eingesetzt, sowohl für [[Klassifikation (maschinelles Lernen)|Klassifikationsaufgaben]] als auch für [[Regression (maschinelles Lernen)|Regressionsaufgaben]].

=== Funktionsweise ===

Der Algorithmus zum Erstellen eines Entscheidungsbaums zielt darauf ab, die Daten anhand der Merkmale (Features) so aufzuteilen, dass die resultierenden Teilmengen (repräsentiert durch die Äste) hinsichtlich der Zielvariable (die vorherzusagende Variable) möglichst homogen sind. Dieser Prozess wird rekursiv für jede Teilmenge wiederholt, bis eine Abbruchbedingung erreicht ist (z.B. alle Datenpunkte in einem Knoten gehören zur selben Klasse oder eine vordefinierte Tiefe des Baumes ist erreicht).

Die Auswahl des zu testenden Merkmals an jedem inneren Knoten basiert auf bestimmten Kriterien, die die "Reinheit" der resultierenden Teilmengen maximieren. Häufig verwendete Kriterien sind:

* '''Gini-Koeffizient:''' Ein Maß für die statistische Streuung der Klassen innerhalb eines Knotens (für Klassifikation). Ein niedriger Gini-Koeffizient deutet auf eine hohe Reinheit hin.
* '''Entropie und Informationsgewinn:''' Entropie misst die Unsicherheit oder Zufälligkeit in einem Knoten (für Klassifikation). Der Informationsgewinn gibt an, wie stark die Entropie durch die Aufteilung anhand eines bestimmten Merkmals reduziert wird.
* '''Varianzreduktion:''' Für Regressionsaufgaben wird das Merkmal gewählt, das die Varianz der Zielvariable in den resultierenden Teilmengen am stärksten reduziert.

=== Vorteile ===

* '''Leicht verständlich und interpretierbar:''' Die resultierenden Entscheidungsbäume können visuell dargestellt und die Entscheidungsfindung nachvollzogen werden.
* '''Keine Annahmen über die Datenverteilung:''' Entscheidungsbäume können auch bei nicht-linearen Beziehungen und komplexen Datenstrukturen gut funktionieren.
* '''Umgang mit kategorischen und numerischen Daten:''' Entscheidungsbäume können sowohl mit diskreten als auch mit kontinuierlichen Merkmalen arbeiten.
* '''Feature Selection (implizit):''' Der Algorithmus wählt automatisch die relevantesten Merkmale für die Klassifikation oder Regression aus.

=== Nachteile ===

* '''Überanpassung (Overfitting):''' Komplexe Entscheidungsbäume können dazu neigen, die Trainingsdaten zu gut zu lernen und auf neuen, unbekannten Daten schlecht zu generalisieren. Gegenmaßnahmen sind z.B. das Beschneiden des Baumes (Pruning) oder die Begrenzung der Baumtiefe.
* '''Instabilität:''' Kleine Änderungen in den Trainingsdaten können zu signifikant unterschiedlichen Baumstrukturen führen.
* '''Suboptimale Entscheidungen:''' Der gierige (greedy) Ansatz, der beim Aufbau von Entscheidungsbäumen verwendet wird, garantiert nicht immer den global optimalen Baum.

=== Anwendungsbeispiele im Maschinellen Lernen ===

* '''Kreditrisikobewertung:''' Entscheidung, ob ein Kreditantrag genehmigt werden soll oder nicht.
* '''Diagnose in der Medizin:''' Unterstützung bei der Identifizierung von Krankheiten anhand von Symptomen.
* '''Spam-Filterung:''' Klassifizierung von E-Mails als Spam oder Nicht-Spam.
* '''Produktempfehlungen:''' Vorhersage, welche Produkte ein Nutzer wahrscheinlich kaufen wird.

== Erweiterungen und verwandte Konzepte ==

* '''Random Forest:''' Ein Ensemble-Lernverfahren, das aus einer Vielzahl von Entscheidungsbäumen besteht und durch Mittelung der Vorhersagen robuster und genauer ist.
* '''Gradient Boosting Machines (GBM):''' Eine weitere Ensemble-Methode, die sequenziell Entscheidungsbäume aufbaut, wobei jeder neue Baum versucht, die Fehler des vorherigen Baumes zu korrigieren.
* '''CART (Classification and Regression Trees):''' Ein spezifischer Algorithmus zur Erstellung von Entscheidungsbäumen, der sowohl für Klassifikations- als auch für Regressionsaufgaben verwendet werden kann.
* '''ID3, C4.5, C5.0:''' Frühere und weiterentwickelte Algorithmen zur Erstellung von Entscheidungsbäumen für Klassifikationsaufgaben.

== Fazit ==

Entscheidungsbäume sind ein vielseitiges und intuitives Werkzeug sowohl für die allgemeine Entscheidungsfindung als auch für komplexe Aufgaben im [[Maschinelles Lernen]]. Ihre Fähigkeit, Entscheidungen und deren Konsequenzen klar zu visualisieren und gleichzeitig leistungsstarke Vorhersagemodelle zu erstellen, macht sie zu einer wichtigen Methode in vielen Anwendungsbereichen. Trotz einiger Nachteile, wie der Neigung zur Überanpassung, bleiben Entscheidungsbäume und ihre Weiterentwicklungen ein fundamentaler Bestandteil des Werkzeugkastens von Data Scientists und Analysten.

[[Kategorie:AHR_I_Informatik_LK]]

Primitiver Datentyp

2026-10-08T14:34:30Z

Flbkwikiadmin:

== Einführung ==

Primitive [[Datentyp|Datentypen]] sind in [[Java]] aus Performancegründen nicht als [[Klasse|Klassen]] realisiert. Primitive [[Datentyp|Datentypen]] verfügen somit auch nicht über [[Methode|Methoden]], die aufgerufen werden können. Es existiert aber in der Klassen-Bibliothek des [[JRE]] für jeden primitiven Datentypen eine Wrapper-[[Klasse]], die einige Methoden zum Umgang mit diesen Objekten zur Verfügung stellt. Die folgende Tabelle listet die primitiven Objekttypen, die Java bereithält, auf (siehe [https://openbook.galileocomputing.de/javainsel openbook.galileocomputing.de/javainsel]):

{| class="wikitable"
! Datentyp !! Beschreibung !! Größe (Bit) !! Wertebereich
|-
| byte || Ganze Zahl || 8 || -128 bis 127
|-
| short || Ganze Zahl || 16 || -32768 bis 32767
|-
| int || Ganze Zahl || 32 || -2147483648 bis 2147483647
|-
| long || Ganze Zahl || 64 || -9223372036854775808 bis 9223372036854775807
|-
| float || [[Gleitkommazahl]] (einfache Genauigkeit) || 32 || ±3.40282347E+38
|-
| double || [[Gleitkommazahl]] (doppelte Genauigkeit) || 64 || ±1.79769313486231570E+308
|-
| char || Unicode-Zeichen || 16 || \u0000 bis \uffff
|-
| boolean || Wahrheitswert || 1 || true oder false
|}

Die numerischen Datentypen `byte`, `short`, `int`, `long`, `float` und `double` sind vorzeichenbehaftet. Negative Werte sind also darstellbar.

In der Programmierung werden Variablen verwendet, um Daten abzulegen. Eine Variable ist ein reservierter Speicherbereich und belegt – abhängig vom Datentyp – eine feste Anzahl von Bytes. Alle primitiven Datentypen haben eine festgesetzte Länge, die sich unter keinen Umständen ändert. Z.B. der Datentyp `char` ist 16 Bit lang. Es ist nicht möglich einer Variable einen Wert zuzuweisen, der außerhalb des Wertebereichs seines Datentyps liegt. Probleme gibt es, wenn wir einem `byte` zum Beispiel den Wert 240 zuweisen wollen, denn 240 liegt außerhalb des Wertebereichs, der von –128 bis 127 reicht (siehe [https://openbook.galileocomputing.de/javainsel openbook.galileocomputing.de/javainsel]).

== Deklaration ==

Mit Variablen lassen sich Daten speichern, die vom Programm gelesen und geschrieben werden können. Um Variablen zu nutzen, müssen sie deklariert werden. Dies gilt für lokale und [[Instanzvariable|Instanzvariablen]]. Die Schreibweise einer Variablendeklaration ist immer die gleiche: Hinter dem Datentypennamen folgt der Name der Variablen. Sie ist eine Anweisung und wird daher mit einem Semikolon abgeschlossen. Immer dann, wenn der Variablentyp der gleiche ist, lässt sich die Deklaration verkürzen: Variablen werden mit Komma getrennt.

Bei der Variablen Deklaration ist darauf zu achten, dass der Datentyp so gewählt wird, dass ausreichend Speicher reserviert wird, um die möglichen Werte abbilden zu können. Andererseits sollten keine Ressourcen verschwendet werden, indem man einen unnötig großen Speicherbereich blockiert.

=== Beispiel ===

<syntaxhighlight lang="java" line>
public class Termin {
// Deklarationen von Instanzvariablen mit primitiven und komplexen Datentypen
String datum;
Kunde kunde;
Mitarbeiter mitarbeiter;
double rechnungsbetrag, anzahl;

// Deklarationen von lokalen Variablen als Eingabeparameter mit primitiven und komplexen Datentypen
public Termin(Kunde kunde, Mitarbeiter mitarbeiter, String datum, double rechnungsbetrag) {
this.kunde = kunde;
this.mitarbeiter = mitarbeiter;
this.datum = datum;
this.rechnungsbetrag = rechnungsbetrag;
}
// ...
}
</syntaxhighlight>
== Initialisierung ==

Wird eine Variable deklariert, werden ihr je nach Datentyp folgende Werte automatisch als initiale Werte zugewiesen (siehe [https://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html docs.oracle.com/javase/tutorial/]):

{| class="wikitable"
! Datentyp !! Initialwert
|-
| byte, short, int, long || 0
|-
| float, double || 0.0
|-
| char || '\u0000' (Nullzeichen)
|-
| boolean || false
|}

[[Kategorie:Programmierung]]
[[Kategorie:AHR_I_Informatik_LK]]
[[Kategorie:FI_I_SDM]]
[[Kategorie:FI_I_TP1]]

Datei:LineareFunktionOrthogonaleGeraden.png

2026-10-08T14:32:07Z

Flbkwikiadmin:

Orthogonale Geraden mit <math>f(x) = 2x + 3</math> und <math>g(x) = -\frac{1}{2}x + 3</math>

Varianz (Statistik)

2026-10-01T08:55:33Z

Flbkwikiadmin: /* Definition */

Wurden [[Häufigkeit#Statistische Begriffe|Merkmalsausprägungen]] zu einem [[Häufigkeit#Statistische Begriffe|quantitativen Merkmal]] erhoben, ist die Varianz das arithmetische Mittel der quadrierten Abweichungen der Merkmalsausprägungen vom Mittelwert. Die Varianz quantifiziert also, wie stark die einzelnen Datenpunkte im Datensatz um den Mittelwert streuen.

==Definition==
Es sei eine Zahlenfolge <math>x_1, x_2, \dots, x_n \in \mathbb{R}</math> mit <math>n \in \mathbb{N}</math> und dem [[Arithmetisches Mittel|arithmetischen Mittel]] <math>\bar{x}</math> gegeben, dann heißt <math>s^2 = \frac{(x_1 - \bar{x})^2 + (x_2 - \bar{x})^2 + \dots + (x_n - \bar{x})^2}{n}</math> '''Varianz'''.

<html><iframe width="280" height="157.5" src="https://www.youtube.com/embed/1glDhGv8ORE?si=CNr6CIL_EroQ7LWk" 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></html>

==Varianz und Häufigkeiten==
Es seien <math>x_1, x_2, \dots, x_k</math> die verschiedenen [[Häufigkeit#Statistische Begriffe|Merkmalsausprägungen]] eines [[Häufigkeit#Statistische Begriffe|quantitativen Merkmals]] mit den jeweiligen [[Häufigkeit#Definition|absoluten Häufigkeiten]] <math>a_1, a_2, \dots, a_k \in \mathbb{N}</math>. Der [[Häufigkeit#Statistische Begriffe|Erhebungsumfang]] sei <math>n</math>, wobei <math>\sum_{i=1}^{k} a_i = n</math> gilt. Mit dem [[Arithmetisches Mittel|arithmetischen Mittel]] <math>\bar{x}</math> heißt der Wert
<math>s^2 = \frac{a_1 \cdot (x_1 - \bar{x})^2 + a_2 \cdot (x_2 - \bar{x})^2 + \dots + a_k \cdot (x_k - \bar{x})^2}{n}</math>
'''Varianz'''.

==Standardabweichung==
Es sei eine Zahlenfolge <math>x_1, x_2, \dots, x_n \in \mathbb{R}</math> mit <math>n \in \mathbb{N}</math> und der Varianz <math>s^2</math> gegeben, dann heißt <math>s = \sqrt{s^2}</math> '''Standardabweichung'''.

==Beispiele==
===Varianz und Standardabweichung berechnen===
Die folgende Tabelle zeigt ein Beispiel für eine [[Häufigkeit#Statistische Begriffe|Urliste]]. Die [[Häufigkeit#Statistische Begriffe|Stichprobe]] besteht aus den betrachteten Schülern. Für das [[Häufigkeit#Statistische Begriffe|quantitative Merkmal]] Körpergröße in cm wird die Varianz berechnet.
{| class="wikitable"
|-
! Schüler Nr.
| 1 || 2 || 3 || 4 || 5 || 6 || 7 || 8 || 9
|-
! Körpergröße in cm
| 183 || 172 || 163 || 154 || 158 || 166 || 177 || 188 || 190
|}

# Die Merkmalsausprägungen des Merkmals Körpergröße in cm sind die Werte 183, 172, 163, 154, 158, 166, 177, 188 und 190.
# Der Erhebungsumfang beträgt 9, da die Körpergröße von 9 Schülern erhoben wurde.
# Das arithmetische Mittel ist <math>\bar{x} = \frac{183 + 172 + 163 + 154 + 158 + 166 + 177 + 188 + 190}{9} \approx 172{,}33</math>.
# Die Varianz ist <math>s^2 = \frac{(183 - 172{,}33)^2 + (172 - 172{,}33)^2 + (163 - 172{,}33)^2 + (154 - 172{,}33)^2 + (158 - 172{,}33)^2 + (166 - 172{,}33)^2 + (177 - 172{,}33)^2 + (188 - 172{,}33)^2 + (190 - 172{,}33)^2}{9} \approx 151{,}23</math>.
# Die Standardabweichung ist <math>s = \sqrt{151{,}23} \approx 12{,}29</math>.

===Varianz und Standardabweichung mit Häufigkeiten berechnen===
Fügen wir noch einen 10. Schüler mit der Körpergröße 154 cm hinzu, so erhalten wir die folgende Urliste:
{| class="wikitable"
|-
! Schüler Nr.
| 1 || 2 || 3 || 4 || 5 || 6 || 7 || 8 || 9 || 10
|-
! Körpergröße in cm
| 183 || 172 || 163 || 154 || 158 || 166 || 177 || 188 || 190 || 154
|}

# Die Merkmalsausprägungen des Merkmals Körpergröße in cm sind die Werte 183, 172, 163, 154, 158, 166, 177, 188 und 190.
# Der Erhebungsumfang beträgt 10, da die Körpergröße von 10 Schülern erhoben wurde.
# Die absolute Häufigkeit der Merkmalsausprägung 154 ist 2, da zwei Schüler 154 cm groß sind.
# Die absoluten Häufigkeiten der restlichen Merkmalsausprägungen sind 1, da jede andere Körpergröße nur genau einmal vorkommt.
# Das arithmetische Mittel ist <math>\bar{x} = \frac{183 + 172 + 163 + 154 + 158 + 166 + 177 + 188 + 190 + 2 \cdot 154}{10} = 170{,}5</math>.
# Die Varianz ist <math>s^2 = \frac{2 \cdot (154 - 170{,}5)^2 + (183 - 170{,}5)^2 + (172 - 170{,}5)^2 + (163 - 170{,}5)^2 + (158 - 170{,}5)^2 + (166 - 170{,}5)^2 + (177 - 170{,}5)^2 + (188 - 170{,}5)^2 + (190 - 170{,}5)^2}{10} = 166{,}45</math>.
# Die Standardabweichung ist <math>s = \sqrt{166{,}45} \approx 12{,}90</math>.

Die Abweichung vom Mittelwert ist in diesem Beispiel größer als zuvor. Die Körpergrößen der Schüler weisen also eine höhere Streuung auf.

[[Kategorie:Statistik]]
[[Kategorie:FHR_WuV_Mathe]]
[[Kategorie:AHR_WuV_Mathe_GK]]

DQL

2026-10-01T05:35:39Z

Flbkwikiadmin:

== Einführung ==
Die '''Data Query Language''' (kurz '''DQL''') der [[SQL|Structured Query Language (SQL)]] ermöglicht es, mittels Abfragen Informationen aus unterschiedlichen Tabellen zusammenzutragen. Das Ergebnis einer Abfrage ist eine [[Relation]] und kann oft auch wie eine Tabelle angezeigt, bearbeitet und weiterverwendet werden. Abfragen basieren auf den Operationen der '''relationalen Algebra'''.

<html><iframe width="280" height="157.5" src="https://www.youtube.com/embed/8L3U4j8CNwE?si=jc7IvK8IMsuai9lp" 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></html>

== Datenbasis ==
[[Datei:DQLDatenbasisERM.jpg|mini|ERM-Modell zur Datenbasis]]
[[Datei:DQLDatenbasisTabellen.jpg|mini|Tabellenübersicht]]
Um die Syntax von SQL-Abfragen nachvollziehen zu können, wird die Datenbasis eines Friseursalons verwendet (siehe Bilder). Die Abfragen beziehen sich auf Tabellen wie `Mitarbeiter`, `Salon`, `Kunde` und `Termin`.

== Auswahl (SELECT) ==
Eine Abfrage beginnt mit der Auswahl anzuzeigender Spalten durch das Schlüsselwort '''SELECT'''.
* Spalten werden durch Komma getrennt.
* Mit einem Sternchen (`*`) werden alle Spalten ausgewählt.
* Bei mehreren Tabellen wird die Punkt-Notation verwendet: `Tabellenname.Spaltenname`.

=== Alias (AS) ===
Nach jeder Spalte kann mit dem Schlüsselwort '''AS''' ein neuer Name (Alias) für die Anzeige festgelegt werden.
<syntaxhighlight lang="sql">
SELECT Nachname AS Mitarbeitername, IdMitarbeiter FROM Mitarbeiter;
</syntaxhighlight>

== Datenherkunft (FROM) ==
Nach dem Schlüsselwort '''FROM''' werden alle Tabellen angegeben, die von der Abfrage betroffen sind. Es muss mindestens eine Tabelle angegeben werden.

'''Einfache Abfrage mit Spaltenauswahl:'''
<syntaxhighlight lang="sql">
SELECT nachname, vorname FROM Mitarbeiter;
</syntaxhighlight>

'''Ergebnis:'''
{| class="wikitable"
! nachname !! vorname
|-
| Krause || Sabine
|-
| Schrotter || Claudia
|-
| Hermann || Markus
|-
| Krause || Christoph
|-
| Bitter || Manuel
|}

== Filter (WHERE) ==
Ein Filter schränkt die Ergebnismenge auf Datensätze ein, für die eine Aussage im Sinne der '''booleschen Algebra''' wahr ist. Er wird durch '''WHERE''' eingeleitet. Neben den Operatoren `<>` und `=` kann auch '''BETWEEN''' eingesetzt werden, um Ober- und Untergrenze eines Filters gleichzeitig anzugeben.

'''Beispiel komplexer Filter:'''
<syntaxhighlight lang="sql">
SELECT Vorname, Nachname FROM Mitarbeiter
WHERE (Nachname = 'Krause' OR Vorname = 'Manuel') AND IdMitarbeiter <> 1;
</syntaxhighlight>

'''Ergebnis:'''
{| class="wikitable"
! Vorname !! Nachname
|-
| Christoph || Krause
|-
| Manuel || Bitter
|}

=== IS NULL ===
SQL nutzt '''NULL-Werte''' für fehlende Informationen. Die Prüfung erfolgt mit `IS NULL` oder `IS NOT NULL`. Dies ist besonders bei äußeren Verbünden (Outer Joins) wichtig.
<syntaxhighlight lang="sql">
SELECT * FROM Termin WHERE Datum IS NOT NULL;
</syntaxhighlight>

== Sortierung und Begrenzung ==

=== ORDER BY ===
Mit '''ORDER BY''' wird die Sortierreihenfolge festgelegt.
* '''ASC:''' aufsteigend (Standard)
* '''DESC:''' absteigend

<syntaxhighlight lang="sql">
SELECT Nachname, Vorname FROM Mitarbeiter ORDER BY Nachname ASC;
</syntaxhighlight>

=== Top-N-Zeilen (LIMIT) ===
Bei MySQL und PostgreSQL wird die Ergebnismenge durch '''LIMIT''' beschränkt, um z. B. nur die aktuellsten Einträge zu erhalten.
<syntaxhighlight lang="sql">
SELECT * FROM Warenkorbposition ORDER BY Datum DESC LIMIT 10;
</syntaxhighlight>

== Tabellen verknüpfen (JOINs) ==
Werden Informationen unterschiedlicher Tabellen zusammengefügt, müssen diese über Schlüsselfelder verbunden werden.

=== Innerer natürlicher Verbund (INNER JOIN) ===
Zeigt nur Datensätze an, für die in beiden Tabellen eine Entsprechung existiert.
<html>
<svg width="200" height="120" viewBox="0 0 200 120">
<circle cx="70" cy="60" r="50" stroke="black" stroke-width="2" fill="white" />
<circle cx="130" cy="60" r="50" stroke="black" stroke-width="2" fill="white" />
<clipPath id="inner">
<circle cx="70" cy="60" r="50" />
</clipPath>
<circle cx="130" cy="60" r="50" fill="#3498db" clip-path="url(#inner)" />
<text x="45" y="65" font-size="12">Tab. A</text>
<text x="135" y="65" font-size="12">Tab. B</text>
</svg>
</html>

<syntaxhighlight lang="sql">
SELECT Salon.IdSalon, Salon.Name AS Salonname, Mitarbeiter.Nachname
FROM Salon
INNER JOIN Mitarbeiter ON Salon.IdSalon = Mitarbeiter.FKSalon;
</syntaxhighlight>
'''Ergebnis:''' (Salon 3 "Kaiserschnitt" erscheint nicht, da ihm kein Mitarbeiter zugeordnet ist)
{| class="wikitable"
! IdSalon !! Salonname !! Nachname
|-
| 1 || Friedrich List Frisuren || Krause
|-
| 1 || Friedrich List Frisuren || Schrotter
|-
| 1 || Friedrich List Frisuren || Hermann
|-
| 2 || Hammer Haare || Krause
|-
| 2 || Hammer Haare || Bitter
|}

=== Linker äußerer Verbund (LEFT JOIN) ===
Alle Datensätze der linken Tabelle (Tab. A) werden angezeigt. Die der rechten Tabelle nur bei Übereinstimmung, sonst `NULL`.
<html>
<svg width="200" height="120" viewBox="0 0 200 120">
<circle cx="130" cy="60" r="50" stroke="black" stroke-width="2" fill="white" />
<circle cx="70" cy="60" r="50" stroke="black" stroke-width="2" fill="#3498db" />
<text x="45" y="65" font-size="12">Tab. A</text>
<text x="135" y="65" font-size="12">Tab. B</text>
</svg>
</html>

<syntaxhighlight lang="sql">
SELECT Salon.Name AS Salonname, Mitarbeiter.Nachname
FROM Salon
LEFT JOIN Mitarbeiter ON Salon.IdSalon = Mitarbeiter.FKSalon;
</syntaxhighlight>
'''Ergebnis:'''
{| class="wikitable"
! Salonname !! Nachname
|-
| Friedrich List Frisuren || Krause
|-
| Friedrich List Frisuren || Schrotter
|-
| Friedrich List Frisuren || Hermann
|-
| Hammer Haare || Krause
|-
| Hammer Haare || Bitter
|-
| Kaiserschnitt || ''NULL''
|}

=== Rechter äußerer Verbund (RIGHT JOIN) ===
Alle Einträge der rechten Tabelle (Tab. B) werden selektiert, auch wenn keine Verbindung zur linken besteht.
<html>
<svg width="200" height="120" viewBox="0 0 200 120">
<circle cx="70" cy="60" r="50" stroke="black" stroke-width="2" fill="white" />
<circle cx="130" cy="60" r="50" stroke="black" stroke-width="2" fill="#3498db" />
<text x="45" y="65" font-size="12">Tab. A</text>
<text x="135" y="65" font-size="12">Tab. B</text>
</svg>
</html>

<syntaxhighlight lang="sql">
-- Hier: Alle Salons (Rechts) anzeigen, auch wenn keine Mitarbeiter (Links) zugeordnet sind
SELECT Mitarbeiter.Nachname, Salon.Name AS Salonname
FROM Mitarbeiter
RIGHT JOIN Salon ON Mitarbeiter.FKSalon = Salon.IdSalon;
</syntaxhighlight>
'''Ergebnis:'''
{| class="wikitable"
! Nachname !! Salonname
|-
| Krause || Friedrich List Frisuren
|-
| Schrotter || Friedrich List Frisuren
|-
| Hermann || Friedrich List Frisuren
|-
| Krause || Hammer Haare
|-
| Bitter || Hammer Haare
|-
| ''NULL'' || Kaiserschnitt
|}

== Gruppierung und Aggregat-Funktionen ==
Mit '''GROUP BY''' werden Datensätze aggregiert (z. B. `COUNT`, `SUM`, `AVG`). Möchte man die Datensätze in einer gruppierten Abfrage filtern, muss '''HAVING''' anstatt `WHERE` verwendet werden.

<syntaxhighlight lang="sql">
SELECT SUM(Termin.Rechnungsbetrag) AS Umsatz, Mitarbeiter.Nachname AS Mitarbeiter
FROM TERMIN
INNER JOIN Mitarbeiter ON Termin.FKMitarbeiter = Mitarbeiter.IdMitarbeiter
GROUP BY Mitarbeiter.IdMitarbeiter
HAVING Umsatz > 100;
</syntaxhighlight>
'''Ergebnis:'''
{| class="wikitable"
! Umsatz !! Mitarbeiter
|-
| 106 || Schrotter
|}

== Unterabfragen (Verschachtelt) ==
Unterabfragen werden in Klammern gesetzt und liefern Werte für die Hauptabfrage.
<syntaxhighlight lang="sql">
-- Termine mit unterdurchschnittlichem Umsatz
SELECT TerminID, Rechnungsbetrag FROM Termin
WHERE Rechnungsbetrag < (SELECT AVG(Rechnungsbetrag) FROM Termin);
</syntaxhighlight>

== UNION ==
Mit '''UNION''' werden zwei Relationen vereint. Die Spalten müssen vom gleichen Typ sein.
<syntaxhighlight lang="sql">
SELECT Mitarbeiter.nachname FROM Mitarbeiter
UNION
SELECT Kunde.nachname FROM Kunde;
</syntaxhighlight>

== Reihenfolge der Abarbeitung ==
Das DBMS arbeitet eine DQL-Abfrage logisch in dieser Reihenfolge ab:
# '''FROM''' (inkl. JOINs)
# '''WHERE'''
# '''GROUP BY'''
# '''HAVING'''
# '''SELECT'''
# '''ORDER BY'''
# '''LIMIT'''

[[Kategorie:Datenbanken]]
[[Kategorie:FI_I_SDM]]
[[Kategorie:FI_I_TP2]]

Datenbank Management System

2026-10-01T05:34:56Z

Flbkwikiadmin:

'''Datenbankmanagementsysteme''' (abgekürzt '''DBMS''', englisch ''Database Management System'') sind Systemprogramme, die die strukturierte Speicherung von [[Daten]] in [[Datenbank]]en organisieren und alle lesenden und schreibenden Zugriffe kontrollieren. Sie sind ein wesentlicher Bestandteil moderner IT-Architekturen.

== Einführung ==
[[Datei:DBMS-Schichten.png|mini]]
Ein Datenbankmanagementsystem organisiert die strukturierte Speicherung von [[Daten]] in Datenbanken und kontrolliert alle lesenden und schreibenden Zugriffe. Zur Wahrung der [[Datenkonsistenz|Konsistenz]] des Datenbestandes müssen sich alle Anwendungssysteme an das DBMS wenden, um die Datenbank nutzen zu können.

Ein DBMS selbst gehört zur Kategorie der [[Systemsoftware]], sorgt für eine dauerhafte Sicherung der [[Daten]] auf einem Speichermedium und ist ein wichtiger Bestandteil von [[Mehrschichtenarchitektur|mehrschichtigen Architekturen]]. Es gibt sehr viele Anbieter von DBMS. Ein sehr weitverbreitetes Produkt ist [[MySQL]].

Zur Abfrage und Verwaltung der [[Daten]] bietet ein Datenbanksystem unterschiedliche Techniken. Dies hängt von der Art der Datenbank ab. So hat sich zum Beispiel die [[SQL|Structured Query Language]] (SQL) als Standard für relationale Datenbanken etabliert.

<html><iframe width="280" height="157.5" src="https://www.youtube.com/embed/JHAMvdowgnI?si=P9a5QGmWnpQw4-e-" 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>
<iframe width="280" height="157.5" src="https://www.youtube.com/embed/HDszYAWyPn8?si=SKQw45vMUTd52GJQ" 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></html>

== Funktionen eines DBMS ==

Die wesentlichen Funktionen von heutigen Datenbankmanagementsystemen sind:

* Modellierung von semantischen Modellen wie [[Entity-Relationship-Modell]]en
* Verwaltung mehrerer Datenbanken
* Speicherung, Überschreibung und Löschung von [[Daten]]
* Vorkehrungen zur [[Datensicherheit]] und [[Datenschutz]] durch Rechte- und Rollen-Konzepte
* Vorkehrungen zur [[Datenintegrität]]
* Ermöglichung des [[Mehrbenutzerbetrieb]]s durch das [[Transaktion (Informatik)|Transaktionskonzept]]
* Optimierung von Anfragen
* Ermöglichung von [[Trigger (Datenbank)|Triggern]] und [[Stored Procedure]]s
* Bereitstellung von Kennzahlen über Technik und Betrieb des DBMS

== Arten von Datenbanken ==

=== Relationale Datenbank ===
Datenbanksysteme gibt es in verschiedenen Formen. Die gebräuchlichste Form ist das [[Relationales Datenbankmodell|relationale Datenbankmodell]]. Die Art und Weise, wie ein solches System [[Daten]] speichert und verwaltet, wird durch das [[Datenbankschema]] festgelegt. Das Datenbankschema wird in der Regel aus einem Entity-Relationship-Modell abgeleitet.

=== Objektorientierte Datenbank ===
Am einfachsten lassen sich Objekte in [[Objektorientierte Datenbank|objektorientierten Datenbanken]] serialisieren. Die Idee ist, dass man die im Speicher vorhandenen Objekte um einen persistenten Bereich erweitert, der dann von einer Datenbank verwaltet wird.

=== XML-Datenbanken ===
Ursprünglich ist [[XML]] als eine Sprache zur Darstellung von Dokumenten gestartet, mit der Zeit haben sich jedoch auch XML-Datenbanken entwickelt.

<html>
<iframe width="280" height="157.5" src="https://www.youtube.com/embed/nOeus1zRHBU?si=GgDdPZIgalIXdVp-" 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>
</html>

== Komponenten ==

Ein Datenbankmanagementsystem besteht meist aus einer Administrationsoberfläche und den einzelnen Datenbanken. Datenbanken sind eigenständige Dienste. Die Administrationsoberfläche bietet eine Sicht auf diese Dienste durch eine [[Grafische Benutzeroberfläche|grafische Benutzeroberfläche]]. Standardfunktionen können hier bequem gesteuert werden.

Technisch erfolgt die Interaktion mit einer Datenbank jedoch immer mit Hilfe der Sprache [[SQL]]. Aufgabenstellungen, die über die Standardanforderungen hinausgehen, müssen eigenständig durch SQL-Befehle programmiert werden. Eine Datenbank ist das Ergebnis eines Softwareentwicklungsprozesses.

== Entwicklungsprozess ==
[[Datei:DBMS-Darstellung.png|mini]]
[[Datei:ERM-Softwarentwicklungsprozess.png|mini]]
[[Datei:DBMS-Server.png|mini|Server Architecture (Quelle: https://docs.oracle.com)]]
Zu Beginn wird die zu erstellende Datenbank durch ein semantisches Modell, z.B. ein Entity-Relationship-Modell, konzipiert. Gemäß dieses Designs wird die Datenbank mittels [[Data Definition Language|DDL]] - einem Teil von SQL - implementiert. Das Anlegen, Verändern, Löschen und Einsehen von [[Daten]] einer Datenbank erfolgt durch SQL-Abfragen bzw. -Anfragen. Jede Anfrage wird überprüft, ob sie den Konsistenzbedingungen der Datenbank entspricht. Wenn nicht, wird die Abfrage abgewiesen.

== Architekturtypen ==

=== Stand-Alone-DBMS ===
Die [[Daten]] und das DBMS selbst befinden sich auf einem Rechner. Es können zwar unterschiedliche Anwendungen bzw. Anwender auf die Datenbank zugreifen, allerdings niemals parallel bzw. gleichzeitig. Erst wenn die Anwendung A die Datenbankverbindung zur Stand-Alone-Datenbank X geschlossen hat, kann eine zweite Anwendung B auf diese Datenbank X zugreifen.

=== Client-Server-Architektur ===
Einen anderen Ansatz verfolgen [[Client-Server-Modell|Client-Server-Datenbanken]]: Zugriff auf Dateien des Datenbestandes hat dort nur der Datenbank-Server, der die Arbeitsplatzrechner bedient. Anfragen werden also nicht auf dem Arbeitsplatzrechner bearbeitet, sondern auf dem Datenbank-Server, es werden dann nur die Ergebnisse an die Arbeitsplatzrechner geschickt. Hinzu kommt, dass Client-Server-Systeme meist viel besser auf den Umgang mit großen Datenmengen ausgerichtet sind.

== Hersteller und Produkte ==
[[Datei:DBMS-MySQL.png|mini]]
Es gibt eine Vielzahl von Anbietern und Produkten auf dem Markt. Alle basieren auf der Programmiersprache SQL. Jedoch verwendet jeder Hersteller einen anderen Dialekt dieser Sprache. Hier eine willkürliche Auswahl von Herstellern und Produkten:

* [[Microsoft Access]] von Microsoft
* [[Microsoft SQL Server]] von Microsoft
* [[MySQL]] von Oracle Cooperation
* [[PostgreSQL]] von PostgreSQL Global Development Group
* und viele andere

== Siehe auch ==
* [[Datenbank]]
* [[SQL]]
* [[Datenbankschema]]
* [[Transaktion (Informatik)]]
* [[Datenmodellierung]]

[[Kategorie:Datenbanken]]
[[Kategorie:FI_I_SDM]]
[[Kategorie:FI_I_TP2]]

Datenbank

2026-10-01T05:32:48Z

Flbkwikiadmin:

Unter einer '''Datenbank''' (engl. database) versteht man einen logisch zusammengehörigen Datenbestand. Dieser Datenbestand wird von einem laufenden [[Datenbank Management System]] verwaltet und für [[Anwendungsprogramm]]e und Benutzer unsichtbar auf nichtflüchtigen [[Speicher]]medien abgelegt.

== Relationale Datenbank ==
'''Relationale Datenbanken''' sind der traditionelle und weitverbreitetste Datenbanktyp. Sie basieren auf dem relationalen Modell, das [[Daten]] auf Basis von [[Relation]]en verwaltet. Vereinfacht kann man Relationen auch als [[Datenbanktabelle]]n bezeichnen. Die Daten werden in Tabellen mit Zeilen (Datensätze) und Spalten (Attribute) organisiert. Die Beziehungen zwischen den Tabellen werden durch Schlüssel (Primary Keys, Foreign Keys) realisiert. Relationale Datenbanken verwenden die [[Structured_Query_Language|SQL]] (Structured Query Language) für Datenabfragen und -manipulation und garantieren durch ACID-Eigenschaften (Atomarität, Konsistenz, Isolation, Dauerhaftigkeit) hohe Datenintegrität.

<html><iframe width="280" height="157.5" src="https://www.youtube.com/embed/JHAMvdowgnI?si=P9a5QGmWnpQw4-e-" 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></html>

== Nicht-Relationale Datenbank ==
'''Nicht-relationale Datenbanken''' (auch NoSQL-Datenbanken genannt) sind Datenbanken, die nicht dem relationalen Modell folgen. Sie wurden entwickelt, um den Anforderungen moderner Anwendungen gerecht zu werden, die massive Datenmengen, hohe Skalierbarkeit und flexible Datenschemata erfordern. Im Gegensatz zu relationalen Datenbanken verzichten sie oft auf feste Tabellenschemata und SQL.

== NoSQL-Datenbank ==
'''NoSQL-Datenbanken''' (Not only SQL) sind eine Unterkategorie der nicht-relationalen Datenbanken. Sie umfassen verschiedene Datenmodelle:
* ''Dokumentenorientierte Datenbanken'' (z.B. MongoDB): Speichern Daten in dokumentenähnlichen Strukturen (JSON, BSON)
* ''Key-Value-Datenbanken'' (z.B. Redis): Speichern Daten als Schlüssel-Wert-Paare
* ''Spaltenorientierte Datenbanken'' (z.B. Cassandra): Organisieren Daten in Spalten statt Zeilen
* ''Graphdatenbanken'' (z.B. Neo4j): Modellieren Daten als Knoten und Kanten in einem Graphen

NoSQL-Datenbanken bieten häufig eine bessere horizontale Skalierbarkeit und eignen sich besonders für unstrukturierte oder halbstrukturierte Daten.

[[Kategorie:Datenbanken]]
[[Kategorie:FI_I_SDM]]
[[Kategorie:FI_I_TP2]]

Zufallsexperiment

2026-09-28T07:26:06Z

Flbkwikiadmin:

Ein '''Zufallsexperiment''' (auch ''Zufallsversuch'' genannt) ist ein zentraler Grundbegriff der Stochastik und bildet das Fundament der Wahrscheinlichkeitsrechnung. Es beschreibt einen Vorgang, dessen Ausgang trotz genau definierter Bedingungen nicht mit Sicherheit vorhergesagt werden kann. Mehrstufige Zufallsexperimente werden häufig mithilfe von [[Baumdiagramm|Baumdiagrammen]] visualisiert.

==Definition==
Ein Versuch heißt in der Mathematik genau dann '''Zufallsexperiment''', wenn er die folgenden drei Kriterien erfüllt:
#'''Planmäßigkeit:''' Der Versuch wird unter genau festgelegten und reproduzierbaren Versuchsbedingungen durchgeführt.
#'''Wiederholbarkeit:''' Das Experiment kann – zumindest theoretisch – unter identischen Bedingungen beliebig oft wiederholt werden.
#'''Zufälligkeit:''' Das konkrete Ergebnis einer einzelnen Durchführung ist ungewiss und lässt sich nicht mit Sicherheit vorhersagen. Die Gesamtheit aller prinzipiell möglichen Ausgänge ist jedoch vorab bekannt.

===Ergebnis und Ergebnismenge===
*Ein möglicher Ausgang eines Zufallsexperiments heißt '''Ergebnis''' (oft mit dem Kleinbuchstaben <math>e</math> oder <math>\omega</math> bezeichnet).
*Die Zusammenfassung aller denkbaren Ergebnisse in einer [[Menge]] heißt '''Ergebnismenge''' (oder Stichprobenraum). Die Ergebnismenge wird mit dem griechischen Großbuchstaben <math>\Omega</math> (Omega) oder <math>S</math> bezeichnet:
:<math>\Omega = \{e_1, e_2, \dots, e_n\}</math>
*Die Anzahl der Elemente in der Ergebnismenge wird als Mächtigkeit <math>|\Omega|</math> bezeichnet.

<html><iframe width="280" height="157.5" src="https://www.youtube.com/embed/amHe2kAOfzA?si=78jb-3Gu5W26yF30" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe></html>

==Zufallsvariable==
Häufig interessiert bei einem Zufallsexperiment nicht die verbale Beschreibung des Ergebnisses, sondern ein zugeordneter Zahlenwert (z. B. Augensumme, Gewinnbetrag, Anzahl defekter Bauteile).

Eine [[Zufallsexperiment#Zufallsvariable|Zufallsvariable]] (oder ''Zufallsgröße'') <math>X</math> ist eine mathematische Funktion, die jedem Ergebnis <math>\omega \in \Omega</math> eines Zufallsexperiments eindeutig eine reelle Zahl <math>x \in \mathbb{R}</math> zuordnet:

<math>X: \Omega \to \mathbb{R}</math>

Zufallsvariablen werden standardmäßig mit lateinischen Großbuchstaben bezeichnet (z. B. <math>X</math>, <math>Y</math>), während die tatsächlich angenommenen Werte mit Kleinbuchstaben (z. B. <math>x_i</math> oder <math>k</math>) notiert werden.

==Ereignis==
In der Stochastik interessiert man sich oft nicht nur für Einzelergebnisse, sondern dafür, ob der Versuchsausgang eine bestimmte Eigenschaft aufweist.

Jede [[Menge#Teilmenge|Teilmenge]] <math>A</math> der Ergebnismenge <math>\Omega</math> heißt '''Ereignis''' (<math>A \subseteq \Omega</math>). Ein Ereignis <math>A</math> tritt genau dann ein, wenn das bei der Durchführung erzielte Ergebnis ein Element von <math>A</math> ist (<math>\omega \in A</math>).

===Sicheres Ereignis===
Das Ereignis <math>\Omega</math> selbst enthält alle überhaupt denkbaren Ergebnisse. Es tritt bei jeder Durchführung des Zufallsexperiments garantiert ein und heißt daher '''sicheres Ereignis'''. Für seine Wahrscheinlichkeit gilt stets:

<math>P(\Omega) = 1</math>

===Unmögliches Ereignis===
Die [[Menge#Leere Menge|leere Menge]] <math>\emptyset = \{\}</math> enthält keinerlei Ergebnisse. Sie kann bei keinem Versuchsausgang eintreten und heißt daher '''unmögliches Ereignis'''. Für ihre Wahrscheinlichkeit gilt:

<math>P(\emptyset) = 0</math>

===Elementarereignis===
Ein Ereignis, das aus genau einem einzigen Ergebnis besteht (<math>|E| = 1</math>), heißt '''Elementarereignis''':

<math>E = \{\omega\}</math> mit <math>\omega \in \Omega</math>

===Gegenereignis===
Das '''Gegenereignis''' <math>\bar{A}</math> (auch Komplementärereignis) zu einem Ereignis <math>A</math> umfasst alle Ergebnisse der Ergebnismenge <math>\Omega</math>, die nicht in <math>A</math> liegen:

<math>\bar{A} = \Omega \setminus A</math>

Das Gegenereignis tritt genau dann ein, wenn <math>A</math> nicht eintritt. Es gelten die Beziehungen:
*<math>A \cup \bar{A} = \Omega</math> (Vereinigung ergibt das sichere Ereignis)
*<math>A \cap \bar{A} = \emptyset</math> (Ereignis und Gegenereignis schließen sich gegenseitig aus)
*<math>P(\bar{A}) = 1 - P(A)</math>

==Beispiele==

===Zufallsexperiment: Einmaliger Wurf eines idealen Würfels===
Ein regelmäßiger sechsseitiger Würfel wird geworfen und die oben liegende Augenzahl erfasst. Die Versuchsbedingungen sind konstant, der Wurf ist beliebig oft wiederholbar und das Ergebnis ist nicht determinierbar.
*'''Ergebnismenge:''' <math>\Omega = \{1, 2, 3, 4, 5, 6\}</math> mit <math>|\Omega| = 6</math>
*'''Zufallsvariable:''' <math>X</math> gibt die gewürfelte Augenzahl an. Der Ausdruck <math>X = 3</math> beschreibt das Ereignis, dass genau eine 3 fällt.
*'''Mögliches Ergebnis:''' <math>\omega = 3</math>
*'''Elementarereignis:''' <math>E_1 = \{1\}</math> (Es fällt die Zahl 1)
*'''Zusammengesetztes Ereignis:''' „Es wird keine 2 und keine 3 gewürfelt“ entspricht <math>A = \{1, 4, 5, 6\}</math>
*'''Sicheres Ereignis:''' <math>\Omega = \{1, 2, 3, 4, 5, 6\}</math> („Es fällt eine Zahl von 1 bis 6“)
*'''Unmögliches Ereignis:''' <math>\emptyset</math> (z. B. „Es wird eine 7 gewürfelt“)
*'''Gegenereignis:''' Für das Ereignis <math>B = \{1, 2\}</math> („Augenzahl höchstens 2“) lautet das Gegenereignis:
:<math>\bar{B} = \Omega \setminus B = \{3, 4, 5, 6\}</math> („Augenzahl mindestens 3“)

===Zufallsexperiment: Dreifacher Münzwurf===
Eine faire Münze wird dreimal nacheinander geworfen. Es wird notiert, in welcher Reihenfolge Kopf (K) und Zahl (Z) fallen.
*'''Ergebnismenge:''' Alle Kombinationen aus drei Würfen:
:<math>\Omega = \{\mathrm{ZZZ}, \mathrm{ZZK}, \mathrm{ZKZ}, \mathrm{ZKK}, \mathrm{KZZ}, \mathrm{KZK}, \mathrm{KKZ}, \mathrm{KKK}\}</math> mit <math>|\Omega| = 2^3 = 8</math>
*'''Einzelergebnis:''' <math>\omega = \mathrm{ZKZ}</math> (1. Wurf: Zahl, 2. Wurf: Kopf, 3. Wurf: Zahl)
*'''Elementarereignis:''' <math>E = \{\mathrm{ZKZ}\}</math>
*'''Ereignis:''' „Es fällt kein einziger Kopf“ entspricht <math>A = \{\mathrm{ZZZ}\}</math>
*'''Zusammengesetztes Ereignis:''' „Es fällt zwei- oder dreimal hintereinander Zahl“:
:<math>B = \{\mathrm{ZZZ}, \mathrm{ZZK}, \mathrm{KZZ}\}</math>
*'''Sicheres Ereignis:''' <math>\Omega</math> („Bei allen drei Würfen fällt jeweils Kopf oder Zahl“)
*'''Unmögliches Ereignis:''' <math>\emptyset</math> (z. B. „Die Münze zeigt ein Symbol, das weder Kopf noch Zahl ist“)
*'''Gegenereignis:''' Das Gegenereignis zu <math>A = \{\mathrm{ZZZ}\}</math> („Kein Kopf“) bedeutet inhaltlich „Mindestens einmal Kopf“:
:<math>\bar{A} = \Omega \setminus A = \{\mathrm{ZZK}, \mathrm{ZKZ}, \mathrm{ZKK}, \mathrm{KZZ}, \mathrm{KZK}, \mathrm{KKZ}, \mathrm{KKK}\}</math>

[[Kategorie:Wahrscheinlichkeitsrechnung]]
[[Kategorie:FHR WuV Mathe]]
[[Kategorie:AHR WuV Mathe GK]]

Erwartungswert

2026-09-28T07:23:44Z

Flbkwikiadmin:

Gemäß dem [[Empirisches Gesetz der großen Zahlen|empirischen Gesetz der großen Zahlen]] nähern sich die [[Häufigkeit|relativen Häufigkeiten]] der Ergebnisse eines [[Zufallsexperiment|Zufallsexperiments]] bei einer großen Anzahl von Wiederholungen den theoretischen [[Wahrscheinlichkeitsverteilung|Wahrscheinlichkeiten]] an[cite: 1, 2].

Während das empirische [[Arithmetisches Mittel#Arithmetisches Mittel und Häufigkeiten|arithmetische Mittel]] aus den beobachteten relativen Häufigkeiten einer Stichprobe berechnet wird, ist der '''Erwartungswert''' (oft mit <math>\mu</math> oder <math>E(X)</math> bezeichnet) das mit den theoretischen Wahrscheinlichkeiten gewichtete Mittel[cite: 1, 2]. Er gibt den Durchschnittswert an, den die [[Zufallsvariable]] bei sehr vielen Wiederholungen des Zufallsexperiments auf lange Sicht im Mittel annimmt[cite: 1, 2].

==Definition==
Es sei ein Zufallsexperiment mit der endlichen [[Zufallsexperiment#Definition|Ergebnismenge]] <math>\Omega</math> gegeben[cite: 1, 2]. Eine diskrete [[Zufallsvariable]] <math>X</math> nehme die Werte <math>x_1, x_2, \dots, x_n \in \mathbb{R}</math> mit den zugehörigen Wahrscheinlichkeiten <math>P(X = x_i)</math> an (wobei <math>\sum_{i=1}^n P(X = x_i) = 1</math> gilt)[cite: 1, 2].

Der '''Erwartungswert''' <math>\mu = E(X)</math> der Zufallsvariablen <math>X</math> ist definiert als[cite: 1, 2]:

<math>\mu = E(X) = \sum_{i=1}^n x_i \cdot P(X = x_i) = x_1 \cdot P(X = x_1) + x_2 \cdot P(X = x_2) + \dots + x_n \cdot P(X = x_n)</math>[cite: 1, 2]

'''Bedeutung der Bestandteile:'''
*<math>x_i</math> sind die möglichen Realisationen (Werte) der Zufallsvariablen <math>X</math>[cite: 1, 2].
*<math>P(X = x_i)</math> ist die Wahrscheinlichkeit, dass die Zufallsvariable den Wert <math>x_i</math> annimmt[cite: 1, 2].
*<math>\sum_{i=1}^n</math> summiert die gewichteten Werte über alle <math>n</math> möglichen Ausprägungen auf[cite: 1, 2].

<html><iframe width="280" height="157.5" src="https://www.youtube.com/embed/z3SaOb0y6Ug?si=3nvQPoCqJsooVLFo" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe></html>

==Faires Spiel==
In ökonomischen und stochastischen Kontexten wird ein Zufallsexperiment mit finanziellem Einsatz und Gewinnausschüttung als (Glücks-)'''Spiel''' zwischen zwei Parteien (in der Regel Spielteilnehmer und Spielanbieter) modelliert[cite: 1, 2].

Beschreibt die [[Zufallsvariable]] <math>X</math> den Nettogewinn eines Spielers in Geldeinheiten (Gewinnauszahlung abzüglich Spieleinsatz, wobei Auszahlungen als <math>X > 0</math> und Verluste als <math>X < 0</math> dargestellt werden), so dient der Erwartungswert zur Beurteilung der Ausgewogenheit des Spiels[cite: 1, 2]:

Ein Spiel heißt '''fair''', wenn der erwartete Nettogewinn pro Spielrunde gleich null ist[cite: 1, 2]:

<math>E(X) = 0</math>[cite: 1, 2]

'''Beurteilungskriterien für ein Spiel:'''
*'''Faires Spiel (<math>E(X) = 0</math>):''' Auf lange Sicht gewinnt oder verliert im Durchschnitt weder der Spieler noch der Anbieter[cite: 1, 2].
*'''Günstiges Spiel (<math>E(X) > 0</math>):''' Der Spieler erzielt auf lange Sicht einen durchschnittlichen Gewinn pro Runde[cite: 1, 2].
*'''Ungünstiges Spiel (<math>E(X) < 0</math>):''' Der Spieler erzielt auf lange Sicht einen durchschnittlichen Verlust pro Spielrunde (dies ist der typische Fall bei kommerziellen Glücksspielen und Lotterien)[cite: 1, 2].

Alternativ kann die Bruttoauszahlung <math>A</math> betrachtet werden: Ein Spiel ist genau dann fair, wenn der Erwartungswert der Auszahlung exakt dem Einsatz <math>e</math> entspricht (<math>E(A) = e</math>)[cite: 1, 2].

==Beispiele==

===Erwartungswert beim dreifachen Münzwurf===
Eine faire Münze wird dreimal geworfen[cite: 1, 2]. Die [[Zufallsexperiment#Definition|Ergebnismenge]] lautet[cite: 1, 2]:

<math>\Omega = \{\mathrm{ZZZ}, \mathrm{ZZK}, \mathrm{ZKZ}, \mathrm{ZKK}, \mathrm{KZZ}, \mathrm{KZK}, \mathrm{KKZ}, \mathrm{KKK}\}</math>[cite: 1, 2]

Die diskrete [[Zufallsvariable]] <math>X</math> beschreibt die Häufigkeit des Ergebnisses „Zahl“ und kann die Werte <math>x_i \in \{0, 1, 2, 3\}</math> annehmen[cite: 1, 2]. Die zugehörige [[Wahrscheinlichkeitsverteilung]] und die Zwischenschritte zur Berechnung des Erwartungswerts stellen sich wie folgt dar[cite: 1, 2]:

{| class="wikitable" style="text-align:center;"
|-
! Wert <math>x_i</math> (Anzahl Zahl) !! Günstige Ergebnisse aus <math>\Omega</math> !! Wahrscheinlichkeit <math>P(X = x_i)</math> !! Produkt <math>x_i \cdot P(X = x_i)</math>
|-
| 0 || <math>\{\mathrm{KKK}\}</math> || <math>0{,}125</math> || <math>0 \cdot 0{,}125 = 0</math>
|-
| 1 || <math>\{\mathrm{ZKK}, \mathrm{KZK}, \mathrm{KKZ}\}</math> || <math>0{,}375</math> || <math>1 \cdot 0{,}375 = 0{,}375</math>
|-
| 2 || <math>\{\mathrm{ZZK}, \mathrm{ZKZ}, \mathrm{KZZ}\}</math> || <math>0{,}375</math> || <math>2 \cdot 0{,}375 = 0{,}750</math>
|-
| 3 || <math>\{\mathrm{ZZZ}\}</math> || <math>0{,}125</math> || <math>3 \cdot 0{,}125 = 0{,}375</math>
|-
| '''Summe''' || || '''<math>1{,}000</math>''' || '''<math>\mu = 1{,}500</math>'''
|}

Der Erwartungswert berechnet sich durch Summation der Produkte[cite: 1, 2]:

<math>\mu = E(X) = 0 \cdot 0{,}125 + 1 \cdot 0{,}375 + 2 \cdot 0{,}375 + 3 \cdot 0{,}125</math>[cite: 1, 2]

<math>\mu = E(X) = 0 + 0{,}375 + 0{,}750 + 0{,}375 = 1{,}5</math>[cite: 1, 2]

'''Interpretation:'''
Bei sehr vielen Wiederholungen des dreifachen Münzwurfs ist auf lange Sicht durchschnittlich <math>\mu = 1{,}5</math>-mal das Ergebnis „Zahl“ pro Durchgang zu erwarten[cite: 1, 2].

===Einfacher Münzwurf als faires Spiel===
Wir betrachten das Werfen einer fairen Münze[cite: 1, 2]. Das Zufallsexperiment besitzt die Ergebnismenge[cite: 1, 2]:

<math>\Omega = \{\text{Kopf}, \text{Zahl}\}</math>[cite: 1, 2]

Die Spielregeln lauten aus Sicht des Teilnehmers:
*Fällt Kopf, gewinnt der Teilnehmer <math>1\,\text{Euro}</math>[cite: 1, 2].
*Fällt Zahl, verliert der Teilnehmer <math>1\,\text{Euro}</math> (der Anbieter erhält den Euro)[cite: 1, 2].

Die Zufallsvariable <math>X</math> beschreibt den finanziellen Nettogewinn des Teilnehmers in Euro und nimmt die Werte <math>+1</math> und <math>-1</math> an[cite: 1, 2]:

{| class="wikitable" style="text-align:center;"
|-
! Ergebnis aus <math>\Omega</math> !! Gewinn/Verlust <math>x_i</math> (in €) !! Wahrscheinlichkeit <math>P(X = x_i)</math> !! Produkt <math>x_i \cdot P(X = x_i)</math>
|-
| Kopf || <math>+1</math> || <math>\frac{1}{2} = 0{,}5</math> || <math>(+1) \cdot 0{,}5 = +0{,}5</math>
|-
| Zahl || <math>-1</math> || <math>\frac{1}{2} = 0{,}5</math> || <math>(-1) \cdot 0{,}5 = -0{,}5</math>
|-
| '''Summe''' || || '''<math>1{,}0</math>''' || '''<math>E(X) = 0{,}0</math>'''
|}

Der Erwartungswert des Nettogewinns berechnet sich wie folgt[cite: 1, 2]:

<math>E(X) = 1 \cdot P(X = 1) + (-1) \cdot P(X = -1)</math>[cite: 1, 2]

<math>E(X) = 1 \cdot \frac{1}{2} + (-1) \cdot \frac{1}{2} = \frac{1}{2} - \frac{1}{2} = 0</math>[cite: 1, 2]

'''Interpretation:'''
Da der Erwartungswert <math>E(X) = 0</math> beträgt, handelt es sich um ein '''faires Spiel'''[cite: 1, 2]. Weder der Spieler noch der Anbieter kann auf lange Sicht einen systematischen Gewinn erzielen[cite: 1, 2].

[[Kategorie:Wahrscheinlichkeitsrechnung]]
[[Kategorie:FHR WuV Mathe]]
[[Kategorie:AHR WuV Mathe GK]]

Baumdiagramm (Wahrscheinlichkeitsrechnung)

2026-09-28T07:22:24Z

Flbkwikiadmin:

Ein '''Baumdiagramm''' ist eine grafische Darstellung zur Veranschaulichung mehrstufiger [[Zufallsexperiment|Zufallsexperimente]]. Es dient dazu, alle möglichen Ausgänge und [[Zufallsexperiment#Definition|Ergebnisse]] des Experiments übersichtlich zu strukturieren sowie die zugehörige [[Wahrscheinlichkeitsverteilung]] mithilfe der Pfadregeln zu ermitteln.

==Aufbau eines Baumdiagramms==
Ein Baumdiagramm verzweigt sich von links nach rechts (oder von oben nach unten) über die einzelnen Stufen des Zufallsversuchs:

*'''Wurzel (Startknoten):''' Der Ausgangspunkt vor Beginn des Zufallsexperiments.
*'''Kanten (Zweige / Äste):''' Sie stellen die einzelnen Teilschritte bzw. Entscheidungen einer Stufe dar. Jeder Zweig wird mit der jeweiligen Stufenwahrscheinlichkeit beschriftet (bei stochastischer Abhängigkeit mit der entsprechenden [[Bedingte Wahrscheinlichkeit|bedingten Wahrscheinlichkeit]]).
*'''Knoten:''' Die Verzweigungspunkte stellen erreichte Zwischenzustände nach einer Stufe dar.
*'''Pfade:''' Eine zusammenhängende Kette von Kanten, die an der Wurzel beginnt und an einem Endknoten (Blatt) endet, heißt '''Pfad'''. Jeder vollständige Pfad repräsentiert genau ein Elementarergebnis <math>e \in \Omega</math> des Gesamtexperiments.
*'''Endknoten:''' Am Ende jedes Pfades wird das resultierende Ergebnis notiert, meist zusammen mit der berechneten Pfadwahrscheinlichkeit.

<html><iframe width="280" height="157.5" src="https://www.youtube.com/embed/cVmoFlKKJVE?si=5UQKeQHvXJgjtzYT" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe></html>

==Pfadregeln zur Wahrscheinlichkeitsberechnung==
Zur Bestimmung von Wahrscheinlichkeiten in einem Baumdiagramm gelten zwei fundamentale Regeln:

<html><iframe width="280" height="157.5" src="https://www.youtube.com/embed/ZWALk4haajQ?si=NeCjRGKV_jbnxEUk" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe></html>

===1. Pfadregel (Pfadmultiplikationsregel)===
Die Wahrscheinlichkeit eines Ergebnisses (also eines vollständigen Pfades von der Wurzel zum Endknoten) ist gleich dem Produkt der Wahrscheinlichkeiten entlang der Kanten dieses Pfades.

Für einen Pfad mit den Stufenwahrscheinlichkeiten <math>p_1, p_2, \dots, p_n</math> gilt:

<math>P(e) = p_1 \cdot p_2 \cdot \dots \cdot p_n</math>

Bei abhängigen Ereignissen entspricht dies dem Multiplikationssatz für bedingte Wahrscheinlichkeiten:

<math>P(A \cap B) = P(A) \cdot P(B \mid A)</math>

===2. Pfadregel (Pfadadditionsregel)===
Setzt sich ein [[Zufallsexperiment#Ereignis|Ereignis]] <math>E</math> aus mehreren Pfaden (Ergebnissen) zusammen, so ist die Wahrscheinlichkeit des Ereignisses gleich der Summe der Wahrscheinlichkeiten der einzelnen günstigen Pfade.

<math>P(E) = \sum_{e \in E} P(e)</math>

===Knotenregel (Verzweigungsregel)===
Die Summe der Wahrscheinlichkeiten aller Zweige, die von einem gemeinsamen Knoten ausgehen, beträgt stets genau <math>1</math> (bzw. <math>100\,\%</math>):

<math>\sum p_{\text{Zweig}} = 1</math>

==Beispiel: Dreifacher Münzwurf==

===Grafische Modellierung im Baumdiagramm===
[[Datei:WahrscheinlichkeitsrechnungDreiMünz.png|mini|Baumdiagramm zum Zufallsexperiment des dreifachen Münzwurfs]]
Eine faire Münze wird dreimal nacheinander geworfen. Bei jedem Wurf kann entweder Zahl (Z) oder Kopf (K) fallen. Die [[Zufallsexperiment#Definition|Ergebnismenge]] des Gesamtexperiments lautet:

<math>\Omega = \{\mathrm{ZZZ}, \mathrm{ZZK}, \mathrm{ZKZ}, \mathrm{ZKK}, \mathrm{KZZ}, \mathrm{KZK}, \mathrm{KKZ}, \mathrm{KKK}\}</math>

*Vom Startknoten führen zwei Kanten zu den Knoten <math>\mathrm{Z}</math> und <math>\mathrm{K}</math> (1. Wurf).
*Von diesen beiden Knoten verzweigt sich der Baum in der 2. Stufe erneut in jeweils <math>\mathrm{Z}</math> und <math>\mathrm{K}</math>.
*In der 3. Stufe entstehen so insgesamt <math>2^3 = 8</math> Pfade und Endknoten.
*Der Pfad <math>\text{Start} \to \mathrm{Z} \to \mathrm{K} \to \mathrm{Z}</math> beschreibt beispielsweise das Ergebnis: 1. Wurf Zahl, 2. Wurf Kopf, 3. Wurf Zahl (<math>\mathrm{ZKZ}</math>).

Betrachtet man das Ereignis <math>B</math>: „Es erscheint mindestens zweimal hintereinander Zahl“, so umfasst dieses die Pfade:

<math>B = \{\mathrm{ZZZ}, \mathrm{ZZK}, \mathrm{KZZ}\}</math>

===Berechnung der Wahrscheinlichkeiten===
[[Datei:WahrscheinlichkeitsrechnungDreiMünzWahr.png|mini|Baumdiagramm zum Zufallsexperiment des dreifachen Münzwurfs mit Wahrscheinlichkeiten]]
Da die Münze ideal ist, beträgt die Wahrscheinlichkeit bei jedem Einzelwurf für Kopf bzw. Zahl jeweils <math>p = 0{,}5</math>.

Definiert man eine [[Zufallsvariable]] <math>X</math> als die Anzahl der Treffer „Zahl“, so kann <math>X</math> die Werte <math>k \in \{0, 1, 2, 3\}</math> annehmen.

'''Anwendung der 1. Pfadregel (Pfadmultiplikation):'''
Die Wahrscheinlichkeit für das Ergebnis <math>\mathrm{ZZZ}</math> (dreimal Zahl) berechnet sich durch Multiplikation der Kantenwahrscheinlichkeiten:

<math>P(\mathrm{ZZZ}) = P(X = 3) = 0{,}5 \cdot 0{,}5 \cdot 0{,}5 = 0{,}125 = 12{,}5\,\%</math>

Da alle 8 Pfade dieselben Kantenwahrscheinlichkeiten besitzen, hat jeder der 8 Pfade die Wahrscheinlichkeit <math>P(e) = 0{,}125</math> (es liegt ein [[Laplace-Experiment]] vor).

'''Anwendung der 2. Pfadregel (Pfadaddition):'''
*'''Ereignis <math>A</math>:''' „Die ersten beiden Würfe ergeben Zahl“ (<math>A = \{\mathrm{ZZZ}, \mathrm{ZZK}\}</math>):
:<math>P(A) = P(\mathrm{ZZZ}) + P(\mathrm{ZZK}) = 0{,}125 + 0{,}125 = 0{,}250 = 25{,}0\,\%</math>
*'''Ereignis <math>B</math>:''' „Mindestens zweimal hintereinander Zahl“ (<math>B = \{\mathrm{ZZZ}, \mathrm{ZZK}, \mathrm{KZZ}\}</math>):
:<math>P(B) = P(\mathrm{ZZZ}) + P(\mathrm{ZZK}) + P(\mathrm{KZZ}) = 0{,}125 + 0{,}125 + 0{,}125 = 0{,}375 = 37{,}5\,\%</math>

===Wahrscheinlichkeitsverteilung der Zufallsvariablen <math>X</math>===
Fasst man die Pfadwahrscheinlichkeiten nach den Werten der Zufallsvariablen <math>X</math> zusammen, ergibt sich die folgende Verteilungstabelle:

{| class="wikitable" style="text-align:center;"
|-
! Wert <math>k</math> (Anzahl Zahl) !! Günstige Pfade aus <math>\Omega</math> !! Anzahl Pfade !! Wahrscheinlichkeit <math>P(X = k)</math>
|-
| 0 || <math>\{\mathrm{KKK}\}</math> || 1 || <math>1 \cdot 0{,}125 = 0{,}125</math> (<math>12{,}5\,\%</math>)
|-
| 1 || <math>\{\mathrm{ZKK}, \mathrm{KZK}, \mathrm{KKZ}\}</math> || 3 || <math>3 \cdot 0{,}125 = 0{,}375</math> (<math>37{,}5\,\%</math>)
|-
| 2 || <math>\{\mathrm{ZZK}, \mathrm{ZKZ}, \mathrm{KZZ}\}</math> || 3 || <math>3 \cdot 0{,}125 = 0{,}375</math> (<math>37{,}5\,\%</math>)
|-
| 3 || <math>\{\mathrm{ZZZ}\}</math> || 1 || <math>1 \cdot 0{,}125 = 0{,}125</math> (<math>12{,}5\,\%</math>)
|-
| '''Summe''' || || '''8''' || '''<math>1{,}000</math> (<math>100\,\%</math>)'''
|}

[[Kategorie:Wahrscheinlichkeitsrechnung]]
[[Kategorie:FHR WuV Mathe]]
[[Kategorie:AHR WuV Mathe GK]]

Varianz (Wahrscheinlichkeitsrechnung)

2026-09-28T07:21:08Z

Flbkwikiadmin:

Gemäß dem [[Empirisches Gesetz der großen Zahlen|empirischen Gesetz der großen Zahlen]] nähern sich die [[Häufigkeit|relativen Häufigkeiten]] der Ausgänge eines [[Zufallsexperiment|Zufallsexperiments]] bei wachsender Versuchszahl den theoretischen [[Wahrscheinlichkeitsverteilung|Wahrscheinlichkeiten]] an. Während der [[Erwartungswert]] das Zentrum einer Wahrscheinlichkeitsverteilung angibt, beschreiben die '''Varianz''' und die '''Standardabweichung''' als fundamentale Streuungsmaße, wie stark die Werte einer [[Zufallsvariable]] um diesen Erwartungswert streuen. Die Varianz ist definiert als der Erwartungswert der quadrierten Abweichungen der Zufallsvariablen von ihrem Erwartungswert.

==Definition==
Es sei ein Zufallsexperiment mit der endlichen [[Zufallsexperiment#Definition|Ergebnismenge]] <math>\Omega</math> gegeben. Eine diskrete [[Zufallsvariable]] <math>X</math> nehme die Werte <math>x_1, x_2, \dots, x_n \in \mathbb{R}</math> mit den zugehörigen Wahrscheinlichkeiten <math>P(X = x_i)</math> an (wobei <math>\sum_{i=1}^n P(X = x_i) = 1</math> gilt). Es sei <math>\mu = E(X)</math> der [[Erwartungswert]] von <math>X</math>.

Die '''Varianz''' <math>\sigma^2 = V(X)</math> (häufig auch <math>\operatorname{Var}(X)</math>) der Zufallsvariablen <math>X</math> ist definiert als:

<math>V(X) = E\left((X - \mu)^2\right) = \sum_{i=1}^n (x_i - \mu)^2 \cdot P(X = x_i)</math>

In ausführlicher Schreibweise:

<math>V(X) = (x_1 - \mu)^2 \cdot P(X = x_1) + (x_2 - \mu)^2 \cdot P(X = x_2) + \dots + (x_n - \mu)^2 \cdot P(X = x_n)</math>

'''Bedeutung der Bestandteile:'''
*<math>x_i</math> sind die möglichen Realisationen (Werte) der Zufallsvariablen <math>X</math>.
*<math>\mu = E(X)</math> ist der Erwartungswert der Zufallsvariablen.
*<math>(x_i - \mu)</math> stellt die lineare Abweichung des Wertes <math>x_i</math> vom Erwartungswert dar.
*<math>(x_i - \mu)^2</math> ist die quadrierte Abweichung. Durch das Quadrieren werden alle Abweichungen positiv gewertet, und größere Ausreißer werden überproportional stark gewichtet.
*<math>P(X = x_i)</math> ist die Wahrscheinlichkeit für das Eintreten des Wertes <math>x_i</math>.

<html><iframe width="280" height="157.5" src="https://www.youtube.com/embed/z3SaOb0y6Ug?si=3nvQPoCqJsooVLFo" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe></html>

==Standardabweichung==
Da die Varianz durch das Quadrieren der Differenzen in einer quadrierten Maßeinheit vorliegt (z. B. <math>\text{Euro}^2</math> oder <math>\text{Stück}^2</math>), wird zur anschaulichen Interpretation die '''Standardabweichung''' herangezogen.

Für eine diskrete Zufallsvariable <math>X</math> mit der Varianz <math>V(X)</math> ist die Standardabweichung <math>\sigma</math> (Sigma) als die nichtnegative Quadratwurzel aus der Varianz definiert:

<math>\sigma = \sqrt{V(X)} = \sqrt{\sum_{i=1}^n (x_i - \mu)^2 \cdot P(X = x_i)}</math>

'''Interpretation:'''
Die Standardabweichung <math>\sigma</math> besitzt dieselbe Einheit wie die Zufallsvariable <math>X</math> selbst sowie ihr Erwartungswert <math>\mu</math>. Sie beziffert die durchschnittliche bzw. typische Streubreite der Werte um den Erwartungswert.

==Beispiel: Dreifacher Münzwurf==
Eine faire Münze wird dreimal geworfen. Die [[Zufallsexperiment#Definition|Ergebnismenge]] lautet:

<math>\Omega = \{\mathrm{ZZZ}, \mathrm{ZZK}, \mathrm{ZKZ}, \mathrm{ZKK}, \mathrm{KZZ}, \mathrm{KZK}, \mathrm{KKZ}, \mathrm{KKK}\}</math>

Die diskrete [[Zufallsvariable]] <math>X</math> beschreibt die Anzahl der Erfolge („Zahl“). Die Zufallsvariable kann die Werte <math>x_i \in \{0, 1, 2, 3\}</math> annehmen.

Die zugehörige [[Wahrscheinlichkeitsverteilung]] stellt sich tabellarisch wie folgt dar:

{| class="wikitable" style="text-align:center;"
|-
! Wert <math>x_i</math> !! Günstige Ergebnisse aus <math>\Omega</math> !! Wahrscheinlichkeit <math>P(X = x_i)</math>
|-
| <math>0</math> || <math>\{\mathrm{KKK}\}</math> || <math>\frac{1}{8} = 0{,}125</math>
|-
| <math>1</math> || <math>\{\mathrm{ZKK}, \mathrm{KZK}, \mathrm{KKZ}\}</math> || <math>\frac{3}{8} = 0{,}375</math>
|-
| <math>2</math> || <math>\{\mathrm{ZZK}, \mathrm{ZKZ}, \mathrm{KZZ}\}</math> || <math>\frac{3}{8} = 0{,}375</math>
|-
| <math>3</math> || <math>\{\mathrm{ZZZ}\}</math> || <math>\frac{1}{8} = 0{,}125</math>
|-
| '''Summe''' || || <math>1{,}000</math>
|}

===1. Berechnung des Erwartungswerts===
Der [[Erwartungswert]] <math>\mu = E(X)</math> berechnet sich als Summe der Produkte aus den Werten <math>x_i</math> und ihren Wahrscheinlichkeiten <math>P(X = x_i)</math>:

<math>\mu = E(X) = \sum_{i=1}^n x_i \cdot P(X = x_i)</math>

<math>E(X) = 0 \cdot 0{,}125 + 1 \cdot 0{,}375 + 2 \cdot 0{,}375 + 3 \cdot 0{,}125</math>

<math>E(X) = 0 + 0{,}375 + 0{,}750 + 0{,}375 = 1{,}5</math>

Bei einem dreifachen Münzwurf ist im Mittel somit <math>\mu = 1{,}5</math>-mal das Ergebnis „Zahl“ zu erwarten.

===2. Berechnung der Varianz===
Die Varianz ergibt sich durch das Summieren der mit den Eintrittswahrscheinlichkeiten gewichteten quadrierten Abweichungen vom Erwartungswert <math>\mu = 1{,}5</math>:

<math>V(X) = \sum_{i=1}^n (x_i - \mu)^2 \cdot P(X = x_i)</math>

<math>V(X) = (0 - 1{,}5)^2 \cdot 0{,}125 + (1 - 1{,}5)^2 \cdot 0{,}375 + (2 - 1{,}5)^2 \cdot 0{,}375 + (3 - 1{,}5)^2 \cdot 0{,}125</math>

<math>V(X) = (-1{,}5)^2 \cdot 0{,}125 + (-0{,}5)^2 \cdot 0{,}375 + (0{,}5)^2 \cdot 0{,}375 + (1{,}5)^2 \cdot 0{,}125</math>

<math>V(X) = 2{,}25 \cdot 0{,}125 + 0{,}25 \cdot 0{,}375 + 0{,}25 \cdot 0{,}375 + 2{,}25 \cdot 0{,}125</math>

<math>V(X) = 0{,}28125 + 0{,}09375 + 0{,}09375 + 0{,}28125 = 0{,}75</math>

Die Varianz der Zufallsvariablen beträgt <math>V(X) = 0{,}75</math>.

===3. Berechnung der Standardabweichung===
Die Standardabweichung <math>\sigma</math> ist die Quadratwurzel aus der Varianz:

<math>\sigma = \sqrt{V(X)} = \sqrt{0{,}75} \approx 0{,}866 \approx 0{,}87</math>

'''Interpretation des Ergebnisses:'''
Bei einer erwarteten Anzahl von <math>\mu = 1{,}5</math> Treffern beträgt die typische Abweichung (Streuung) rund <math>\sigma \approx 0{,}87</math> Treffer.

[[Kategorie:Wahrscheinlichkeitsrechnung]]
[[Kategorie:FHR WuV Mathe]]
[[Kategorie:AHR WuV Mathe GK]]

Wahrscheinlichkeitsverteilung

2026-09-28T07:19:40Z

Flbkwikiadmin:

Eine '''Wahrscheinlichkeitsverteilung''' für ein [[Zufallsexperiment]] ordnet jedem möglichen Ergebnis bzw. jedem Wert einer [[Zufallsvariable]] eine [[Wahrscheinlichkeit]] zu. Sie beschreibt, wie sich die Gesamtwahrscheinlichkeit von <math>1</math> (entsprechend <math>100\,\%</math>) auf die verschiedenen Ausgänge verteilt, und wird häufig tabellarisch oder durch ein [[Histogramm]] bzw. ein [[Säulendiagramm]] visualisiert.

==Definition==
Es sei <math>\Omega = \{e_1, e_2, \dots, e_n\}</math> die endliche [[Zufallsexperiment#Definition|Ergebnismenge]] eines Zufallsexperiments mit <math>n \in \mathbb{N}</math> und <math>A \subseteq \Omega</math> ein [[Zufallsexperiment#Ereignis|Ereignis]]. Die reellen Zahlen <math>P(e_i) \in [0; 1]</math> genügen den folgenden Bedingungen (in Anlehnung an die Kolmogorov-Axiome):

#'''Nichtnegativität und Beschränktheit:''' <math>0 \leq P(e_i) \leq 1</math> für alle <math>i \in \{1, \dots, n\}</math>
#'''Normierung:''' Die Summe aller Einzelwahrscheinlichkeiten der Ergebnismenge beträgt genau <math>1</math>:
#:<math>P(\Omega) = \sum_{i=1}^n P(e_i) = P(e_1) + P(e_2) + \dots + P(e_n) = 1</math>
#'''Additivität für Ereignisse:''' Die Wahrscheinlichkeit eines zusammengesetzten Ereignisses <math>A = \{e_1, e_2, \dots, e_m\}</math> mit <math>m \leq n</math> ist gleich der Summe der Wahrscheinlichkeiten der in <math>A</math> enthaltenen Elementarereignisse:
#:<math>P(A) = \sum_{e \in A} P(e) = P(e_1) + P(e_2) + \dots + P(e_m)</math>

Die Zahl <math>P(e_i)</math> nennt man die '''Wahrscheinlichkeit''' des Ergebnisses <math>e_i</math>. Die [[Funktion]] <math>P: \Omega \to [0; 1]</math> bzw. die Zuordnung auf der Ereignismenge <math>P: \mathcal{P}(\Omega) \to [0; 1]</math> heißt '''Wahrscheinlichkeitsverteilung'''.

<html><iframe width="280" height="157.5" src="https://www.youtube.com/embed/oLQNzQdOtsg?si=LcXSE3NZ91ikQIRr" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe></html>

==Schreibweisen für Wahrscheinlichkeiten==
Es sei <math>X</math> eine diskrete [[Zufallsexperiment#Zufallsvariable|Zufallsvariable]] und <math>k \in \mathbb{N}_0</math>. Zur präzisen mathematischen Beschreibung gelten folgende Konventionen:

*<math>P(X = k)</math> bezeichnet die Wahrscheinlichkeit, dass die Zufallsvariable genau den Wert <math>k</math> annimmt (Einzelwahrscheinlichkeit).
*<math>P(X \leq k)</math> bezeichnet die Wahrscheinlichkeit, dass die Zufallsvariable einen Wert von höchstens <math>k</math> annimmt (kumulierte Wahrscheinlichkeit).
*<math>P(X < k)</math> bezeichnet die Wahrscheinlichkeit, dass die Zufallsvariable einen Wert kleiner als <math>k</math> (also echt kleiner) annimmt.
*<math>P(X \geq k)</math> bezeichnet die Wahrscheinlichkeit, dass die Zufallsvariable einen Wert von mindestens <math>k</math> annimmt.
*<math>P(X > k)</math> bezeichnet die Wahrscheinlichkeit, dass die Zufallsvariable einen Wert größer als <math>k</math> (also mehr als <math>k</math>) annimmt.

Für ganzzahlige Zufallsvariablen (wie bei der Binomialverteilung) und zur Berechnung mit dem [[Taschenrechner verwenden#Wahrscheinlichkeitsrechnung|Taschenrechner]] gelten folgende Umformungsregeln über das Gegenereignis bzw. Nachbarwerte:

*<math>P(X < k) = P(X \leq k - 1)</math>
*<math>P(X > k) = 1 - P(X \leq k)</math>
*<math>P(X \leq k) = 1 - P(X > k)</math>
*<math>P(X \geq k) = 1 - P(X < k) = 1 - P(X \leq k - 1)</math>
*<math>P(X \geq k) = 1 - P(X \leq k) + P(X = k)</math>
*<math>P(k_1 \leq X \leq k_2) = P(X \leq k_2) - P(X \leq k_1 - 1)</math> für <math>k_1, k_2 \in \mathbb{N}_0</math> mit <math>k_1 \leq k_2</math>

==Wahrscheinlichkeiten für Mengen berechnen==
Für ein [[Zufallsexperiment]] mit der Ergebnismenge <math>\Omega</math> seien <math>A</math> und <math>B</math> zwei beliebige [[Zufallsexperiment#Ereignis|Ereignisse]] (<math>A, B \subseteq \Omega</math>).

===Additionssatz (Vereinigung von Ereignissen)===
Die Wahrscheinlichkeit, dass mindestens eines der beiden Ereignisse eintritt (<math>A \cup B</math>), berechnet sich nach dem allgemeinen Additionssatz:

<math>P(A \cup B) = P(A) + P(B) - P(A \cap B)</math>

Sind <math>A</math> und <math>B</math> unvereinbar (disjunkt, d. h. <math>A \cap B = \emptyset</math> und <math>P(A \cap B) = 0</math>), so gilt der spezielle Additionssatz:

<math>P(A \cup B) = P(A) + P(B)</math>

===Multiplikationssatz (Schnittmenge von Ereignissen)===
Für die Wahrscheinlichkeit, dass beide Ereignisse gleichzeitig eintreten (<math>A \cap B</math>), muss differenziert werden:

*'''Allgemeiner Fall (abhängige Ereignisse):''' Unter Verwendung der [[Bedingte Wahrscheinlichkeit|bedingten Wahrscheinlichkeit]] <math>P(B \mid A)</math> bzw. <math>P_A(B)</math> gilt:
:<math>P(A \cap B) = P(A) \cdot P(B \mid A) = P(B) \cdot P(A \mid B)</math>
*'''Spezialfall (stochastisch unabhängige Ereignisse):''' Die Produktformel gilt '''nur dann''', wenn <math>A</math> und <math>B</math> stochastisch unabhängig voneinander sind:
:<math>P(A \cap B) = P(A) \cdot P(B)</math>

==Beispiele==

===Wahrscheinlichkeitsverteilung einfacher Münzwurf===
Beim Wurf einer fairen Münze lautet die Ergebnismenge <math>\Omega = \{\text{Kopf}, \text{Zahl}\}</math>. Beiden Ausgängen wird dieselbe Wahrscheinlichkeit zugeordnet: <math>\text{Kopf} \mapsto \frac{1}{2}</math> und <math>\text{Zahl} \mapsto \frac{1}{2}</math>. Die Wahrscheinlichkeitsverteilung stellt sich tabellarisch wie folgt dar:

{| class="wikitable"
|-
! Ergebnis <math>e_i</math> !! Wahrscheinlichkeit <math>P(e_i)</math>
|-
| Kopf || <math>\frac{1}{2} = 0{,}5</math>
|-
| Zahl || <math>\frac{1}{2} = 0{,}5</math>
|-
| '''Summe''' || <math>1{,}0</math>
|}

===Wahrscheinlichkeitsverteilung einmaliger Wurf eines Würfels===
Die Ergebnismenge beim Wurf eines fairen sechsseitigen Würfels ist <math>\Omega = \{1, 2, 3, 4, 5, 6\}</math>. Die diskrete [[Zufallsexperiment#Zufallsvariable|Zufallsvariable]] <math>X</math> gebe die gewürfelte Augenzahl an (z. B. steht <math>X = 3</math> für das Auftreten der Augenzahl 3). Da ein [[Laplace-Experiment]] mit sechs gleich wahrscheinlichen Ergebnissen vorliegt, lautet die Wahrscheinlichkeitsverteilung:

<math>P(X = k) = \frac{1}{6}</math> für alle <math>k \in \{1, 2, 3, 4, 5, 6\}</math>

In tabellarischer Form (Wahrscheinlichkeitstabelle):

{| class="wikitable" style="text-align:center;"
|-
! Wert <math>k</math> !! 1 !! 2 !! 3 !! 4 !! 5 !! 6 !! Summe
|-
| <math>P(X = k)</math> || <math>\frac{1}{6}</math> || <math>\frac{1}{6}</math> || <math>\frac{1}{6}</math> || <math>\frac{1}{6}</math> || <math>\frac{1}{6}</math> || <math>\frac{1}{6}</math> || <math>1</math>
|}

[[Kategorie:Wahrscheinlichkeitsrechnung]]
[[Kategorie:FHR WuV Mathe]]
[[Kategorie:AHR WuV Mathe GK]]

Binomialverteilung

2026-09-28T07:17:22Z

Flbkwikiadmin:

Die '''Binomialverteilung''' ist eine der wichtigsten diskreten [[Wahrscheinlichkeitsverteilung]]en. Sie beschreibt die Wahrscheinlichkeitsverteilung der Anzahl der Erfolge bei der Durchführung einer [[#Bernoulli-Kette|Bernoulli-Kette]].

==Bernoulli-Experiment==
Ein [[Zufallsexperiment]] mit genau zwei möglichen Ergebnissen (traditionell als „Erfolg“ und „Misserfolg“ bezeichnet) heißt '''Bernoulli-Experiment'''. Die Wahrscheinlichkeit für einen Erfolg wird mit <math>p</math> bezeichnet, die Wahrscheinlichkeit für einen Misserfolg (Gegenwahrscheinlichkeit) mit <math>q = 1 - p</math>. Dabei gilt <math>p \in \mathbb{R}</math> und <math>0 \leq p \leq 1</math>.

==Bernoulli-Kette==
Ein mehrstufiges Zufallsexperiment, das aus <math>n \in \mathbb{N}</math> unabhängigen Durchführungen desselben Bernoulli-Experiments besteht (wobei die Erfolgswahrscheinlichkeit <math>p</math> bei jeder Durchführung konstant bleibt), heißt '''Bernoulli-Kette''' der Länge <math>n</math>.

<html><iframe width="280" height="157.5" src="https://www.youtube.com/embed/8B3qmuQk2xs?si=fK9vNYCvhEIa1tpH" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe></html>

==Definition==
Gegeben ist eine Bernoulli-Kette der Länge <math>n \in \mathbb{N}</math> mit der konstanten Erfolgswahrscheinlichkeit <math>p</math> (<math>p \in \mathbb{R}</math> mit <math>0 \leq p \leq 1</math>). Die diskrete [[Zufallsvariable]] <math>X</math> gibt die Anzahl der Erfolge an. Dann beträgt die [[Wahrscheinlichkeit]] für genau <math>k</math> Erfolge:

<math>P(X = k) = \binom{n}{k} \cdot p^k \cdot (1 - p)^{n - k}</math>

mit <math>k \in \{0, 1, \dots, n\}</math>. Die Funktion <math>P: \{0, 1, \dots, n\} \to [0; 1]</math> heißt '''Binomialverteilung''' mit den Parametern <math>n</math> und <math>p</math>. Für <math>P(X = k)</math> schreibt man auch <math>B_{n;p}(k)</math> oder <math>B(n; p; k)</math> und nennt <math>X</math> eine '''<math>B_{n;p}</math>-verteilte Zufallsvariable'''.

Der Term <math>\binom{n}{k} = \frac{n!}{k! \cdot (n - k)!}</math> ist der [[Kombinatorik#Binomialkoeffizient|Binomialkoeffizient]] („<math>n</math> über <math>k</math>“). Er gibt die Anzahl der Pfade im Baumdiagramm an, die zu genau <math>k</math> Erfolgen führen.

<html><iframe width="280" height="157.5" src="https://www.youtube.com/embed/2IBw_ynpGSE?si=nFU0jEdSyV6YOcHC" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe></html>

==Eigenschaften==
===Erwartungswert===
Es sei <math>X</math> eine <math>B_{n;p}</math>-verteilte [[Zufallsvariable]] mit <math>n \in \mathbb{N}</math> und <math>p \in \mathbb{R}</math> (<math>0 \leq p \leq 1</math>). Dann ist:

<math>\mu = E(X) = n \cdot p</math>

der [[Erwartungswert]] von <math>X</math>.

===Varianz===
Es sei <math>X</math> eine <math>B_{n;p}</math>-verteilte [[Zufallsvariable]] mit <math>n \in \mathbb{N}</math> und <math>p \in \mathbb{R}</math> (<math>0 \leq p \leq 1</math>). Dann ist:

<math>\sigma^2 = V(X) = n \cdot p \cdot (1 - p)</math>

die [[Varianz (Wahrscheinlichkeitsrechnung)|Varianz]] von <math>X</math>.

===Standardabweichung===
Es sei <math>X</math> eine <math>B_{n;p}</math>-verteilte [[Zufallsvariable]] mit <math>n \in \mathbb{N}</math> und <math>p \in \mathbb{R}</math> (<math>0 \leq p \leq 1</math>). Dann ist:

<math>\sigma = \sqrt{V(X)} = \sqrt{n \cdot p \cdot (1 - p)}</math>

die Standardabweichung von <math>X</math>.

===Histogramm===
Im folgenden Video wird das [[Histogramm]] der Binomialverteilung erläutert.

<html><iframe width="280" height="157.5" src="https://www.youtube.com/embed/Lc_R0vBSKHw?si=V72WfOUjhQRQlrN9" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe></html>

==Sigmaregeln==
Es sei <math>X</math> eine <math>B_{n;p}</math>-verteilte Zufallsvariable mit <math>n \in \mathbb{N}</math> und <math>p \in \mathbb{R}</math> (<math>0 \leq p \leq 1</math>). Sofern die Laplace-Bedingung <math>\sigma \geq 3</math> erfüllt ist, gelten folgende Näherungswerte:

*<math>P(\mu - \sigma \leq X \leq \mu + \sigma) \approx 0{,}683</math> (<math>1\sigma</math>-Regel, ca. 68,3 %)
*<math>P(\mu - 2\sigma \leq X \leq \mu + 2\sigma) \approx 0{,}955</math> (<math>2\sigma</math>-Regel, ca. 95,5 %)
*<math>P(\mu - 3\sigma \leq X \leq \mu + 3\sigma) \approx 0{,}997</math> (<math>3\sigma</math>-Regel, ca. 99,7 %)
*<math>P(\mu - 1{,}64\sigma \leq X \leq \mu + 1{,}64\sigma) \approx 0{,}900</math> (90-%-Regel)
*<math>P(\mu - 1{,}96\sigma \leq X \leq \mu + 1{,}96\sigma) \approx 0{,}950</math> (95-%-Regel)
*<math>P(\mu - 2{,}58\sigma \leq X \leq \mu + 2{,}58\sigma) \approx 0{,}990</math> (99-%-Regel)

Diese Regeln können im [[Histogramm#Histogramm der Binomialverteilung|Histogramm]] grafisch dargestellt werden.

==Regeln zum Umformen von Wahrscheinlichkeiten==
Um Wahrscheinlichkeiten für eine <math>B_{n;p}</math>-verteilte [[Zufallsvariable]] <math>X</math> mit dem [[Taschenrechner verwenden#Wahrscheinlichkeitsrechnung|Taschenrechner]] (z. B. über die kumulierte Binomialverteilung) zu bestimmen, müssen die Wahrscheinlichkeiten auf die Form <math>P(X \leq k)</math> umgeformt werden. Für <math>k_1, k_2 \in \mathbb{N}_0</math> mit <math>k_1 \leq k_2</math> gelten die folgenden Regeln (siehe auch [[Wahrscheinlichkeitsverteilung#Schreibweisen für Wahrscheinlichkeiten|Größer-Kleiner-Zeichen]]):

*<math>P(X = k_1)</math> kann mit dem [[Taschenrechner verwenden#Wahrscheinlichkeitsrechnung|Taschenrechner]] direkt berechnet werden (Einzelwahrscheinlichkeit)
*<math>P(X \leq k_1)</math> kann mit dem [[Taschenrechner verwenden#Wahrscheinlichkeitsrechnung|Taschenrechner]] direkt berechnet werden (kumulierte Wahrscheinlichkeit)
*<math>P(X < k_1) = P(X \leq k_1 - 1)</math>
*<math>P(X > k_1) = 1 - P(X \leq k_1)</math>
*<math>P(X \geq k_1) = 1 - P(X < k_1) = 1 - P(X \leq k_1 - 1)</math>
*<math>P(k_1 \leq X \leq k_2) = P(X \leq k_2) - P(X \leq k_1 - 1)</math>
*<math>P(k_1 < X < k_2) = P(k_1 + 1 \leq X \leq k_2 - 1) = P(X \leq k_2 - 1) - P(X \leq k_1)</math>

<html><iframe width="280" height="157.5" src="https://www.youtube.com/embed/voPP8Z7jGsA?si=jSxTL6FH6qnIPSq7" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe><iframe width="280" height="157.5" src="https://www.youtube.com/embed/EPzXRrErLaM?si=L8btUsbwukYRyZJA" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe></html>

==Auslastungsmodell==
Mittels der Formel:

<math>P(X = k) = \binom{n}{k} \cdot \left(\frac{m}{60}\right)^k \cdot \left(1 - \frac{m}{60}\right)^{n - k}</math>

lässt sich die Wahrscheinlichkeit dafür errechnen, dass <math>k \in \mathbb{N}_0</math> von <math>n \in \mathbb{N}</math> Personen eine Tätigkeit, die durchschnittlich <math>m \in [0; 60]</math> Minuten pro Stunde dauert, zu einem zufällig ausgewählten Zeitpunkt gleichzeitig ausführen. Die Einzelwahrscheinlichkeit beträgt hierbei <math>p = \frac{m}{60}</math>.

<html><iframe width="280" height="157.5" src="https://www.youtube.com/embed/dkrErCbQ6Bw?si=euhahtXHnZI9Rf3O" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe></html>

==Beispiele==
===Bernoulli-Experiment einfacher Münzwurf===
Das [[Zufallsexperiment]] des einfachen Münzwurfs mit den beiden Ergebnissen Zahl (Erfolg) und Kopf (Misserfolg) ist ein Bernoulli-Experiment. Die Ergebnismenge lautet <math>\Omega = \{\text{Zahl}, \text{Kopf}\}</math>. Für die Erfolgswahrscheinlichkeit gilt <math>p = \frac{1}{2}</math> (Zahl) und für die Gegenwahrscheinlichkeit <math>q = 1 - \frac{1}{2} = \frac{1}{2}</math> (Kopf).

===Bernoulli-Kette zweifacher Münzwurf===
Der zweifache Münzwurf ist ein Beispiel für eine Bernoulli-Kette der Länge <math>n = 2</math>, da die beiden Durchführungen stochastisch unabhängig voneinander sind. Das bedeutet, dass bei jedem Wurf die Wahrscheinlichkeit für Zahl mit <math>p = \frac{1}{2}</math> und für Kopf mit <math>q = \frac{1}{2}</math> konstant bleibt.

===Binomialverteilung beim 20-maligen Werfen eines Würfels===
Wir betrachten als Bernoulli-Kette das 20-malige Werfen eines fairen Würfels (<math>n = 20</math>). Eine 6 zu würfeln bedeutet Erfolg, jede andere Augenzahl bedeutet Misserfolg. Das einmalige Werfen des Würfels ist ein Bernoulli-Experiment mit der Erfolgswahrscheinlichkeit <math>p = \frac{1}{6}</math> und der Misserfolgswahrscheinlichkeit <math>q = 1 - \frac{1}{6} = \frac{5}{6}</math>. Damit ist die Zufallsvariable <math>X</math> (Häufigkeit der Augenzahl 6) eine <math>B_{20;\frac{1}{6}}</math>-verteilte Zufallsvariable.

Die Wahrscheinlichkeit, beim 20-maligen Werfen genau 3-mal eine 6 zu würfeln, beträgt:

<math>P(X = 3) = \binom{20}{3} \cdot \left(\frac{1}{6}\right)^3 \cdot \left(1 - \frac{1}{6}\right)^{20 - 3} = 1140 \cdot \left(\frac{1}{6}\right)^3 \cdot \left(\frac{5}{6}\right)^{17} \approx 0{,}238 = 23{,}8\,\%</math>

===Binomialverteilung beim dreifachen Münzwurf===
[[Datei:WahrscheinlichkeitsrechnungDreiMünzWahr.png|mini|Baumdiagramm zum Zufallsexperiment des dreifachen Münzwurfs mit Wahrscheinlichkeiten]]
Eine Münze wird dreimal geworfen (<math>n = 3</math>) und man beobachtet, in welcher Reihenfolge Zahl (Z) und Kopf (K) oben liegen. Die [[Zufallsexperiment#Definition|Ergebnismenge]] ist:

<math>\Omega = \{\mathrm{ZZZ}, \mathrm{ZZK}, \mathrm{ZKZ}, \mathrm{ZKK}, \mathrm{KZZ}, \mathrm{KZK}, \mathrm{KKZ}, \mathrm{KKK}\}</math>

Da alle 8 Elementarereignisse gleich wahrscheinlich sind, liegt ein [[Laplace-Experiment]] vor. Das Ereignis <math>E</math>, genau zweimal Kopf zu werfen, umfasst die Ergebnisse <math>E = \{\mathrm{KKZ}, \mathrm{KZK}, \mathrm{ZKK}\}</math>. Die [[Wahrscheinlichkeit]] beträgt demnach:

<math>P(E) = \frac{|E|}{|\Omega|} = \frac{3}{8} = 0{,}375 = 37{,}5\,\%</math>

Unter Anwendung der Formel der Binomialverteilung betrachten wir die Zufallsvariable <math>X</math>, welche die Anzahl der Erfolge (Kopf) angibt. Bei <math>n = 3</math> und <math>p = \frac{1}{2}</math> ist <math>X</math> nach <math>B_{3;\frac{1}{2}}</math> verteilt. Gesucht ist <math>P(X = 2)</math>. Jeder [[Baumdiagramm#Definition|Pfad]] besteht aus 3 [[Baumdiagramm#Definition|Teilpfaden]], wovon genau 2 zu Kopf führen müssen. Da die Anordnung der Erfolge eine Kombination ohne Wiederholung darstellt, gibt es insgesamt <math>\binom{3}{2} = 3</math> günstige Pfade (siehe: [[Kombinatorik#Anzahl möglicher Ergebnisse bei einem Zufallsexperiment ermitteln|Kombinatorik: Ohne Beachtung der Reihenfolge, ohne Zurücklegen]]).

Für jeden einzelnen dieser Pfade gilt nach der 1. Pfadregel: Zwei Teilpfade besitzen jeweils die Wahrscheinlichkeit <math>\frac{1}{2}</math> für Kopf und ein Teilpfad besitzt die Wahrscheinlichkeit <math>\frac{1}{2}</math> für Zahl:

<math>P(X = 2) = \binom{3}{2} \cdot \left(\frac{1}{2}\right)^2 \cdot \left(1 - \frac{1}{2}\right)^{3 - 2} = 3 \cdot \left(\frac{1}{2}\right)^2 \cdot \left(\frac{1}{2}\right)^1 = 3 \cdot \frac{1}{4} \cdot \frac{1}{2} = \frac{3}{8} = 0{,}375</math>

*<math>\binom{3}{2} = 3</math> entspricht der Anzahl günstiger Pfade (genau zwei Erfolge bei 3 Versuchen).
*<math>\left(\frac{1}{2}\right)^2</math> ist die Wahrscheinlichkeit für zwei Erfolge (Kopf).
*<math>\left(\frac{1}{2}\right)^1</math> ist die Wahrscheinlichkeit für einen Misserfolg (Zahl).

===Anwendung: Erwartungswert, Varianz, Standardabweichung und 95-%-Regel===
Im Alter zwischen 15 und 20 Jahren rauchen statistisch 25,5 % der deutschen Bevölkerung. An einer Schule mit 640 Schülerinnen und Schülern dieser Altersgruppe rauchen 118 Jugendliche.

Betrachten wir die Zufallsvariable <math>X</math> als Anzahl der rauchenden Personen in der Stichprobe, liegt unter Modellannahmen eine Bernoulli-Kette mit den Parametern <math>n = 640</math> und <math>p = 0{,}255</math> vor:

*'''Erwartungswert:''' <math>\mu = E(X) = n \cdot p = 640 \cdot 0{,}255 = 163{,}2</math>
*'''Varianz:''' <math>\sigma^2 = V(X) = n \cdot p \cdot (1 - p) = 640 \cdot 0{,}255 \cdot 0{,}745 = 121{,}584</math>
*'''Standardabweichung:''' <math>\sigma = \sqrt{V(X)} = \sqrt{121{,}584} \approx 11{,}03</math>

Da <math>\sigma \approx 11{,}03 \geq 3</math> ist, ist die Laplace-Bedingung erfüllt und die Sigmaregeln liefern hinreichend genaue Näherungswerte.

Einsetzen in die 95-%-Regel (<math>P(\mu - 1{,}96\sigma \leq X \leq \mu + 1{,}96\sigma) \approx 0{,}95</math>):

<math>P(163{,}2 - 1{,}96 \cdot 11{,}03 \leq X \leq 163{,}2 + 1{,}96 \cdot 11{,}03) \approx 0{,}95</math>

<math>P(163{,}2 - 21{,}62 \leq X \leq 163{,}2 + 21{,}62) \approx 0{,}95</math>

<math>P(141{,}58 \leq X \leq 184{,}82) \approx 0{,}95</math>

Für ganzzahlige Anzahlen von Personen ergibt sich somit das 95-%-Prognoseintervall:

<math>P(142 \leq X \leq 184) \approx 0{,}95</math>

'''Interpretation:'''
Unter der Annahme einer bundesweiten Raucherquote von 25,5 % ist mit einer Wahrscheinlichkeit von 95 % zu erwarten, dass an der Schule zwischen 142 und 184 Schülerinnen und Schüler rauchen. Die tatsächliche Anzahl von 118 Rauchenden liegt mit mehr als <math>4\sigma</math> unter dem Erwartungswert (<math>\frac{163{,}2 - 118}{11{,}03} \approx 4{,}1</math>) und damit deutlich außerhalb des Intervalls. Dies lässt darauf schließen, dass der Anteil rauchender Jugendlicher an dieser Schule signifikant unter dem Bundesdurchschnitt liegt.

[[Kategorie:Wahrscheinlichkeitsrechnung]]
[[Kategorie:FHR WuV Mathe]]
[[Kategorie:AHR WuV Mathe GK]]

Varianz (Statistik)

2026-09-18T08:35:11Z

Flbkwikiadmin:

Wurden [[Häufigkeit#Statistische Begriffe|Merkmalsausprägungen]] zu einem [[Häufigkeit#Statistische Begriffe|quantitativen Merkmal]] erhoben, ist die Varianz das arithmetische Mittel der quadrierten Abweichungen der Merkmalsausprägungen vom Mittelwert. Die Varianz quantifiziert also, wie stark die einzelnen Datenpunkte im Datensatz um den Mittelwert streuen.

==Definition==
Es sei eine Zahlenfolge <math>x_1, x_2, \dots, x_n \in \mathbb{R}</math> mit <math>n \in \mathbb{N}</math> und dem [[Arithmetisches Mittel|arithmetischen Mittel]] <math>\bar{x}</math> gegeben, dann heißt <math>s^2 = \frac{(x_1 - \bar{x})^2 + (x_2 - \bar{x})^2 + \dots + (x_n - \bar{x})^2}{n}</math> '''Varianz'''.

<html><iframe width="280" height="157.5" src="https://www.youtube.com/embed/maEsC-e7hkA?si=Cguc4VtTTmFPrWiH" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe></html>

==Varianz und Häufigkeiten==
Es seien <math>x_1, x_2, \dots, x_k</math> die verschiedenen [[Häufigkeit#Statistische Begriffe|Merkmalsausprägungen]] eines [[Häufigkeit#Statistische Begriffe|quantitativen Merkmals]] mit den jeweiligen [[Häufigkeit#Definition|absoluten Häufigkeiten]] <math>a_1, a_2, \dots, a_k \in \mathbb{N}</math>. Der [[Häufigkeit#Statistische Begriffe|Erhebungsumfang]] sei <math>n</math>, wobei <math>\sum_{i=1}^{k} a_i = n</math> gilt. Mit dem [[Arithmetisches Mittel|arithmetischen Mittel]] <math>\bar{x}</math> heißt der Wert
<math>s^2 = \frac{a_1 \cdot (x_1 - \bar{x})^2 + a_2 \cdot (x_2 - \bar{x})^2 + \dots + a_k \cdot (x_k - \bar{x})^2}{n}</math>
'''Varianz'''.

==Standardabweichung==
Es sei eine Zahlenfolge <math>x_1, x_2, \dots, x_n \in \mathbb{R}</math> mit <math>n \in \mathbb{N}</math> und der Varianz <math>s^2</math> gegeben, dann heißt <math>s = \sqrt{s^2}</math> '''Standardabweichung'''.

==Beispiele==
===Varianz und Standardabweichung berechnen===
Die folgende Tabelle zeigt ein Beispiel für eine [[Häufigkeit#Statistische Begriffe|Urliste]]. Die [[Häufigkeit#Statistische Begriffe|Stichprobe]] besteht aus den betrachteten Schülern. Für das [[Häufigkeit#Statistische Begriffe|quantitative Merkmal]] Körpergröße in cm wird die Varianz berechnet.
{| class="wikitable"
|-
! Schüler Nr.
| 1 || 2 || 3 || 4 || 5 || 6 || 7 || 8 || 9
|-
! Körpergröße in cm
| 183 || 172 || 163 || 154 || 158 || 166 || 177 || 188 || 190
|}

# Die Merkmalsausprägungen des Merkmals Körpergröße in cm sind die Werte 183, 172, 163, 154, 158, 166, 177, 188 und 190.
# Der Erhebungsumfang beträgt 9, da die Körpergröße von 9 Schülern erhoben wurde.
# Das arithmetische Mittel ist <math>\bar{x} = \frac{183 + 172 + 163 + 154 + 158 + 166 + 177 + 188 + 190}{9} \approx 172{,}33</math>.
# Die Varianz ist <math>s^2 = \frac{(183 - 172{,}33)^2 + (172 - 172{,}33)^2 + (163 - 172{,}33)^2 + (154 - 172{,}33)^2 + (158 - 172{,}33)^2 + (166 - 172{,}33)^2 + (177 - 172{,}33)^2 + (188 - 172{,}33)^2 + (190 - 172{,}33)^2}{9} \approx 151{,}23</math>.
# Die Standardabweichung ist <math>s = \sqrt{151{,}23} \approx 12{,}29</math>.

===Varianz und Standardabweichung mit Häufigkeiten berechnen===
Fügen wir noch einen 10. Schüler mit der Körpergröße 154 cm hinzu, so erhalten wir die folgende Urliste:
{| class="wikitable"
|-
! Schüler Nr.
| 1 || 2 || 3 || 4 || 5 || 6 || 7 || 8 || 9 || 10
|-
! Körpergröße in cm
| 183 || 172 || 163 || 154 || 158 || 166 || 177 || 188 || 190 || 154
|}

# Die Merkmalsausprägungen des Merkmals Körpergröße in cm sind die Werte 183, 172, 163, 154, 158, 166, 177, 188 und 190.
# Der Erhebungsumfang beträgt 10, da die Körpergröße von 10 Schülern erhoben wurde.
# Die absolute Häufigkeit der Merkmalsausprägung 154 ist 2, da zwei Schüler 154 cm groß sind.
# Die absoluten Häufigkeiten der restlichen Merkmalsausprägungen sind 1, da jede andere Körpergröße nur genau einmal vorkommt.
# Das arithmetische Mittel ist <math>\bar{x} = \frac{183 + 172 + 163 + 154 + 158 + 166 + 177 + 188 + 190 + 2 \cdot 154}{10} = 170{,}5</math>.
# Die Varianz ist <math>s^2 = \frac{2 \cdot (154 - 170{,}5)^2 + (183 - 170{,}5)^2 + (172 - 170{,}5)^2 + (163 - 170{,}5)^2 + (158 - 170{,}5)^2 + (166 - 170{,}5)^2 + (177 - 170{,}5)^2 + (188 - 170{,}5)^2 + (190 - 170{,}5)^2}{10} = 166{,}45</math>.
# Die Standardabweichung ist <math>s = \sqrt{166{,}45} \approx 12{,}90</math>.

Die Abweichung vom Mittelwert ist in diesem Beispiel größer als zuvor. Die Körpergrößen der Schüler weisen also eine höhere Streuung auf.

[[Kategorie:Statistik]]
[[Kategorie:FHR_WuV_Mathe]]
[[Kategorie:AHR_WuV_Mathe_GK]]

Säulendiagramm

2026-09-18T08:33:49Z

Flbkwikiadmin:

[[Häufigkeit|Häufigkeiten]] von Merkmalsausprägungen aus statistischen [[Häufigkeit#Datenerhebung|Datenerhebungen]] können wir mithilfe von Diagrammen darstellen. Wir betrachten im Folgenden das Säulendiagramm.

==Definition==
Zu einem [[Häufigkeit#Statistische Begriffe|Merkmal]] aus einer [[Häufigkeit#Datenerhebung|Datenerhebung]] seien die [[Häufigkeit|Häufigkeiten]] der [[Häufigkeit#Statistische Begriffe|Merkmalsausprägungen]] gegeben. In einem '''Säulendiagramm''' werden auf der waagerechten Achse (x-Achse) die Merkmalsausprägungen und auf der senkrechten Achse (y-Achse) die absoluten oder relativen Häufigkeiten der jeweiligen Merkmalsausprägung eingetragen.

<html><iframe width="280" height="157.5" src="https://www.youtube.com/embed/UDd0EebVV9A?si=X-rpVq5oEb5UIWJW" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe></html>

==Beispiele==
===Ein Säulendiagramm zeichnen===
Ein Würfel wurde 20-mal geworfen. In der folgenden Tabelle sind für das [[Häufigkeit#Statistische Begriffe|Merkmal]] Würfelaugen die [[Häufigkeit|Häufigkeiten]] zu den [[Häufigkeit#Statistische Begriffe|Merkmalsausprägungen]] 1, 2, 3, 4, 5 und 6 festgehalten.
{| class="wikitable"
|-
! Würfelaugen
| 1 || 2 || 3 || 4 || 5 || 6
|-
! Absolute Häufigkeit
| 3 || 2 || 2 || 4 || 5 || 4
|-
! Relative Häufigkeit
| 0,15 || 0,1 || 0,1 || 0,2 || 0,25 || 0,2
|}

Die relativen und absoluten Häufigkeiten werden als Säulendiagramm wie folgt dargestellt:

<gallery heights=400px widths=500px>Datei:StatistikSäulendiagramm.png|Säulendiagramm für die Würfelergebnisse</gallery>

===Häufigkeiten aus einem Säulendiagramm ablesen===
Die Höhe einer Säule gibt die [[Häufigkeit]] an. Bei der Darstellung ist es wichtig, dass auf der y-Achse einheitliche Schritte gewählt wurden. Die [[Häufigkeit#Statistische Begriffe|Merkmalsausprägung]] steht auf der x-Achse. Beispielsweise lässt sich aus dem obigen Säulendiagramm ablesen, dass die Augenzahl 3 insgesamt zweimal gewürfelt wurde. Die relative Häufigkeit beträgt 0,1, d. h. 10 % der Würfe hatten die Augenzahl 3.

[[Kategorie:Statistik]]
[[Kategorie:FHR_WuV_Mathe]]
[[Kategorie:AHR_WuV_Mathe_GK]]

Spannweite

2026-09-18T08:32:49Z

Flbkwikiadmin:

Wurden [[Häufigkeit#Statistische Begriffe|Merkmalsausprägungen]] zu einem [[Häufigkeit#Statistische Begriffe|quantitativen Merkmal]] erhoben, dann gibt die Spannweite die Entfernung zwischen der größten und der kleinsten Merkmalsausprägung an.

==Definition==
Es sei eine Zahlenfolge <math>x_1, x_2, \dots, x_n \in \mathbb{R}</math> mit <math>n \in \mathbb{N}</math> gegeben, dann heißt <math>R = \max\{x_1, x_2, \dots, x_n\} - \min\{x_1, x_2, \dots, x_n\}</math> '''Spannweite'''.

<html><iframe width="280" height="157.5" src="https://www.youtube.com/embed/1glDhGv8ORE?si=lGDGmd-ABKkdgbDd" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe></html>

==Beispiel==
Die folgende Tabelle zeigt ein Beispiel für eine Urliste. Die Stichprobe besteht aus den betrachteten Schülern. Für das quantitative Merkmal Körpergröße in cm wird die Spannweite berechnet.
{| class="wikitable"
|-
! Schüler Nr.
| 1 || 2 || 3 || 4 || 5 || 6 || 7 || 8 || 9
|-
! Körpergröße in cm
| 183 || 172 || 163 || 154 || 158 || 166 || 177 || 188 || 190
|}

# Die größte Merkmalsausprägung ist 190.
# Die kleinste Merkmalsausprägung ist 154.
# Die Spannweite ist <math>R = 190 - 154 = 36</math>.

[[Kategorie:Statistik]]
[[Kategorie:FHR_WuV_Mathe]]
[[Kategorie:AHR_WuV_Mathe_GK]]

Median

2026-09-18T08:32:09Z

Flbkwikiadmin:

Der Median ist ein wichtiges Maß für die zentrale Tendenz eines Datensatzes. Im Gegensatz zum [[Arithmetisches Mittel|arithmetischen Mittel]], das den Durchschnitt aller Werte berechnet, repräsentiert der Median den mittleren Wert, nachdem die [[Daten]] in aufsteigender oder absteigender Reihenfolge sortiert wurden.

Wurden [[Häufigkeit#Statistische Begriffe|Merkmalsausprägungen]] zu einem [[Häufigkeit#Statistische Begriffe|quantitativen Merkmal]] erhoben und nach ihrer Größe sortiert, dann ist der Median bei einer ungeraden Anzahl an Merkmalsausprägungen die Merkmalsausprägung in der Mitte. Bei einer geraden Anzahl an Merkmalsausprägungen wird der [[Arithmetisches Mittel|Durchschnitt]] der beiden mittleren Merkmalsausprägungen als Median bezeichnet.

==Definition==
Es sei eine Zahlenfolge <math>x_1, x_2, \dots, x_n \in \mathbb{R}</math> mit <math>n \in \mathbb{N}</math> gegeben und nach ihrer Größe in nicht absteigender Reihenfolge geordnet, d. h., es gilt <math>x_1 \leq x_2 \leq \dots \leq x_n</math>. Ist die Anzahl <math>n</math> der Zahlenwerte ungerade, heißt der Zahlenwert <math>x_{\frac{n+1}{2}}</math> '''Median'''. Ist die Anzahl <math>n</math> der Zahlenwerte eine gerade Zahl, heißt der Wert <math>\frac{x_{\frac{n}{2}} + x_{\frac{n}{2} + 1}}{2}</math> '''Median'''.

<html><iframe width="280" height="157.5" src="https://www.youtube.com/embed/maEsC-e7hkA?si=Cguc4VtTTmFPrWiH" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe></html>

==Beispiele==
===Median für eine ungerade Anzahl an Zahlenwerten ermitteln===
Die folgende Tabelle zeigt ein Beispiel für eine Urliste. Die Stichprobe besteht aus den betrachteten Schülern. Es wird für das quantitative Merkmal Körpergröße in cm der Median berechnet.
{| class="wikitable"
|-
! Schüler Nr.
| 1 || 2 || 3 || 4 || 5 || 6 || 7 || 8 || 9
|-
! Körpergröße in cm
| 183 || 172 || 163 || 154 || 158 || 166 || 177 || 188 || 190
|}

# Ordnen der Merkmalsausprägungen des Merkmals Körpergröße in cm ergibt: 154; 158; 163; 166; 172; 177; 183; 188; 190.
# Die Anzahl der Merkmalsausprägungen ist ungerade, da der Erhebungsumfang 9 beträgt.
# Der Median ist 172 und befindet sich an der Stelle <math>\frac{9+1}{2} = 5</math>.

===Median für eine gerade Anzahl an Zahlenwerten ermitteln===
Fügen wir noch einen 10. Schüler mit der Körpergröße 154 cm hinzu, so erhalten wir die folgende Urliste:
{| class="wikitable"
|-
! Schüler Nr.
| 1 || 2 || 3 || 4 || 5 || 6 || 7 || 8 || 9 || 10
|-
! Körpergröße in cm
| 183 || 172 || 163 || 154 || 158 || 166 || 177 || 188 || 190 || 154
|}

# Ordnen der Merkmalsausprägungen des Merkmals Körpergröße in cm ergibt: 154; 154; 158; 163; 166; 172; 177; 183; 188; 190.
# Die Anzahl der Merkmalsausprägungen ist gerade, da der Erhebungsumfang 10 beträgt.
# Die Zahlenwerte in der Mitte befinden sich an den Stellen <math>\frac{10}{2} = 5</math> und <math>\frac{10}{2} + 1 = 6</math>. Dort stehen die Werte 166 und 172, von denen wir den [[Arithmetisches Mittel|Durchschnitt]] berechnen. Der Median ist dann <math>\frac{166 + 172}{2} = 169</math>.

[[Kategorie:Statistik]]
[[Kategorie:FHR_WuV_Mathe]]
[[Kategorie:AHR_WuV_Mathe_GK]]

Kreisdiagramm

2026-09-18T08:30:43Z

Flbkwikiadmin:

[[Häufigkeit|Häufigkeiten]] von Merkmalsausprägungen aus statistischen [[Häufigkeit#Datenerhebung|Datenerhebungen]] können wir mithilfe von Diagrammen darstellen. Wir betrachten im Folgenden das Kreisdiagramm.

==Definition==
Zu einem [[Häufigkeit#Statistische Begriffe|Merkmal]] aus einer [[Häufigkeit#Datenerhebung|Datenerhebung]] seien die [[Häufigkeit|Häufigkeiten]] der [[Häufigkeit#Statistische Begriffe|Merkmalsausprägungen]] gegeben. In einem '''Kreisdiagramm''' werden die 360° des Kreises gemäß den relativen Häufigkeiten der Merkmalsausprägungen aufgeteilt. Alternativ kann der Kreis in so viele gleich große Teile geteilt werden, wie der Erhebungsumfang beträgt. Die absolute Häufigkeit einer Merkmalsausprägung für ein Objekt gibt dann an, wie viele Teile des Kreises belegt werden.

<html><iframe width="280" height="157.5" src="https://www.youtube.com/embed/UDd0EebVV9A?si=X-rpVq5oEb5UIWJW" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe></html>

==Beispiele==
===Ein Kreisdiagramm zeichnen===
Ein Würfel wurde 20-mal geworfen. In der folgenden Tabelle sind für das [[Häufigkeit#Statistische Begriffe|Merkmal]] Würfelaugen die [[Häufigkeit|Häufigkeiten]] zu den [[Häufigkeit#Statistische Begriffe|Merkmalsausprägungen]] 1, 2, 3, 4, 5 und 6 festgehalten.
{| class="wikitable"
|-
! Würfelaugen
| 1 || 2 || 3 || 4 || 5 || 6
|-
! Absolute Häufigkeit
| 3 || 2 || 2 || 4 || 5 || 4
|-
! Relative Häufigkeit
| 0,15 || 0,1 || 0,1 || 0,2 || 0,25 || 0,2
|}

Die relative Häufigkeit der Augenzahl 1 beträgt 0,15, demnach müssen <math>0,15\cdot360\text{°}=54\text{°}</math> des Kreises markiert werden.

'''Alternativ''': Im obigen Würfelspiel wurde insgesamt 20-mal geworfen. Teilen wir den Kreis in 20 gleich große Teile auf, dann muss ein Teil einen Winkel von <math>\frac{1}{20}\cdot360\text{°}=18\text{°}</math> haben. Die absolute Häufigkeit der Augenzahl 1 beträgt 3, also werden dafür drei Teile des Kreises markiert. Insgesamt müssen also <math>18\text{°}\cdot 3=54\text{°}</math> des Kreises markiert werden.

Die Kreisdiagramme zum Würfelspiel sehen wie folgt aus:

<gallery heights=500px widths=400px>Datei:StatistikKreis.png|Kreisdiagramm für die Würfelergebnisse</gallery>

===Häufigkeiten aus einem Kreisdiagramm ablesen===
Die Größe eines Kreisausschnitts gibt die [[Häufigkeit]] an. Die [[Häufigkeit#Statistische Begriffe|Merkmalsausprägung]] steht außerhalb des jeweiligen Kreisausschnitts. Die dazugehörige Häufigkeit steht im Kreisausschnitt. Beispielsweise lässt sich aus dem obigen Kreisdiagramm ablesen, dass die Augenzahl 3 insgesamt zweimal gewürfelt wurde. Die relative Häufigkeit beträgt 0,1, d. h. 10 % der Würfe hatten die Augenzahl 3.

[[Kategorie:Statistik]]
[[Kategorie:FHR_WuV_Mathe]]
[[Kategorie:AHR_WuV_Mathe_GK]]

Häufigkeit

2026-09-18T08:29:50Z

Flbkwikiadmin:

In der Statistik werden Daten über reale Phänomene gesammelt, ausgewertet und mit Hilfe von Häufigkeiten analysiert. Das Ziel besteht darin, verlässliche und relevante Daten zu sammeln, die zur Beantwortung von Forschungsfragen, zur Unterstützung von Hypothesen oder zur Entscheidungsfindung genutzt werden können.

==Statistische Begriffe==
Wird der Teil einer '''Gesamtheit''' (ein Gegenstand, ein Phänomen oder ein System) betrachtet und analysiert, dann spricht man von einer '''Stichprobe'''. Das Ergebnis der Stichprobe wird in einer '''Urliste''' festgehalten. Alle in der Urliste enthaltenen Daten bezeichnet man als '''Rohdaten'''. Der '''Erhebungsumfang''' bezeichnet die Anzahl aller betrachteten Objekte. Die Eigenschaften der Objekte bezeichnen wir als '''Merkmale'''. Die Ausprägung eines Merkmals wird als '''Merkmalsausprägung''' <math>x_i</math> bezeichnet. Man unterscheidet zwischen '''quantitativen Merkmalen''' (Zahlen, z. B. 160 cm) und '''qualitativen Merkmalen''' (Wörter, z. B. männlich oder weiblich). Eine '''Klasse''' fasst mehrere Merkmalsausprägungen zu einer Gruppe zusammen.

==Datenerhebung==
Das Sammeln von Daten durch eine Stichprobe mit der Absicht, bestimmte Aussagen über die Gesamtheit zu treffen, nennt man '''Datenerhebung'''. Durch eine Datenerhebung soll festgestellt werden, wie die verschiedenen Ausprägungen eines Merkmals in einer Stichprobe verteilt sind. Vor der Datenerhebung sind die Merkmale, Merkmalsausprägungen und der Erhebungsumfang festzulegen. Anschließend werden die Daten gesammelt und in einer Urliste als Rohdaten festgehalten.

==Definition==
Es sei eine Urliste mit Rohdaten als Ergebnis einer Datenerhebung gegeben. Die '''absolute Häufigkeit''' gibt an, wie oft eine Merkmalsausprägung auftritt. Die '''relative Häufigkeit''' entspricht <math> \frac{\text{absolute Häufigkeit}}{\text{Erhebungsumfang}}</math>. Die '''prozentuale Häufigkeit''' ist durch <math>\text{relative Häufigkeit} \cdot 100 </math> gegeben.

<html><iframe width="280" height="157.5" src="https://www.youtube.com/embed/6YhHUlZlJlI?si=izCyVbejsCgN8qyL" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe></html>

==Beispiele==
Die folgenden Beispiele zeigen, wie die oberen Begriffe verwendet werden können.

====Verwendung der Begriffe====
Die folgende Tabelle zeigt ein Beispiel für eine Urliste. Die Daten in der Urliste sind die Rohdaten. Die Stichprobe sind die befragten Schüler. Der Erhebungsumfang ist 20, da 20 Schüler befragt wurden. Die Gesamtheit sind alle Schüler der Schule.
{| class="wikitable"
|-
! Schüler Nr. !! Geschlecht !! Körpergröße in cm !! Sportart
|-
| 01 || w || 160 || Handball
|-
| 02 || m || 176 || Triathlon
|-
| ... || ... || ... || ...
|-
| 20 || w || 176 || Tanzen
|}

In der obigen Tabelle sind Geschlecht und Sportart qualitative Merkmale. Körpergröße in cm ist ein quantitatives Merkmal. Die Merkmalsausprägung zum Merkmal Geschlecht für Schüler 01 ist <math>x_{\text{Geschlecht}}=\text{w}</math>. Die Merkmalsausprägung zum Merkmal Körpergröße in cm für Schüler 02 ist <math>x_{\text{Körpergröße in cm}}=176</math>.

====Klasse====
Das Ergebnis einer Datenerhebung sei eine Urliste, in der die Noten von Schülern enthalten sind. Das Merkmal Noten hat beispielsweise die Merkmalsausprägungen 1-; 1; 1+. Diese Merkmalsausprägungen können in der Klasse 1 zusammengefasst werden.

====Berechnung der Häufigkeiten====
Ein Würfel wurde 20-mal geworfen und die Augenzahl wurde anschließend in der folgenden Urliste festgehalten:

{| class="wikitable"
|-
! Wurfnummer
| 01 || 02 || 03 || 04 || 05 || 06 || 07 || 08 || 09 || 10 || 11 || 12 || 13 || 14 || 15 || 16 || 17 || 18 || 19 || 20
|-
! Würfelaugen
| 1 || 1 || 1 || <span style="color:green">3</span> || <span style="color:green">3</span> || 2 || 2 || 4 || 4 || 4 || 4 || 5 || 5 || 5 || 5 || 5 || 6 || 6 || 6 || 6
|}
Beispielsweise wurde bei Wurf 11 die 5 gewürfelt. Bei Wurf 4 und 5 wurde jeweils die <span style="color:green">3</span> gewürfelt.

In der folgenden Tabelle wurden die Häufigkeiten der Merkmalsausprägungen zum Merkmal Würfelaugen aus der Urliste berechnet:
{| class="wikitable"
|-
! Würfelaugen
| 1 || 2 || 3 || 4 || 5 || 6
|-
! Absolute Häufigkeit
| 3 || 2 || <span style="color:green">2</span> || 4 || 5 || 4
|-
! Relative Häufigkeit
| <math>\frac{3}{20}=0,15</math> || 0,1 || <span style="color:green">0,1</span> || 0,2 || 0,25 || 0,2
|}
So wurde beispielsweise die Augenzahl 1 insgesamt dreimal und die Augenzahl 6 insgesamt viermal gewürfelt. Der Anteil der Würfe mit Augenzahl 4 an allen Würfen beträgt hierbei <math>\frac{4}{20}= 0,2</math>. Die Augenzahl <span style="color:green">3</span> wurde zweimal gewürfelt, daher ist die absolute Häufigkeit <span style="color:green">2</span> und die relative Häufigkeit <span style="color:green"><math>\frac{2}{20}=0,1</math></span>.

[[Kategorie:Statistik]]
[[Kategorie:FHR_WuV_Mathe]]
[[Kategorie:AHR_WuV_Mathe_GK]]

Arithmetisches Mittel

2026-09-18T08:27:41Z

Flbkwikiadmin:

Das arithmetische Mittel gibt einen typischen oder durchschnittlichen Wert in einem Datensatz an. Es ist ein Maß für das Zentrum der Datenverteilung. Dies ermöglicht es, einen schnellen Überblick über das durchschnittliche Ausprägungsniveau der untersuchten Variablen zu erhalten.

Wurden [[Häufigkeit#Statistische Begriffe|Merkmalsausprägungen]] zu einem [[Häufigkeit#Statistische Begriffe|quantitativen Merkmal]] erhoben, dann ist die Summe aller Merkmalsausprägungen geteilt durch den Erhebungsumfang das arithmetische Mittel, umgangssprachlich auch als Durchschnitt bezeichnet.

==Definition==
Gegeben sei eine Zahlenfolge <math>x_1, x_2, \dots, x_n \in \mathbb{R}</math> mit dem Erhebungsumfang <math>n \in \mathbb{N}</math>. Dann wird <math>\bar{x} = \frac{x_1 + x_2 + \dots + x_n}{n}</math> als '''arithmetisches Mittel''' bezeichnet.

<html><iframe width="280" height="157.5" src="https://www.youtube.com/embed/maEsC-e7hkA?si=Cguc4VtTTmFPrWiH" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe></html>

==Arithmetisches Mittel und Häufigkeiten==
Es seien <math>x_1, x_2, \dots, x_k</math> die verschiedenen [[Häufigkeit#Statistische Begriffe|Merkmalsausprägungen]] eines [[Häufigkeit#Statistische Begriffe|quantitativen Merkmals]] mit den jeweiligen [[Häufigkeit#Definition|absoluten Häufigkeiten]] <math>a_1, a_2, \dots, a_k \in \mathbb{N}</math>. Der [[Häufigkeit#Statistische Begriffe|Erhebungsumfang]] sei <math>n</math>, wobei <math>\sum_{i=1}^{k} a_i = n</math> gilt. Der Wert
<math>\bar{x} = \frac{a_1 \cdot x_1 + a_2 \cdot x_2 + \dots + a_k \cdot x_k}{n} = \frac{a_1}{n} \cdot x_1 + \frac{a_2}{n} \cdot x_2 + \dots + \frac{a_k}{n} \cdot x_k</math>
heißt '''arithmetisches Mittel'''. Dabei ist <math>\frac{a_i}{n}</math> die relative Häufigkeit der Merkmalsausprägung <math>x_i</math>.

==Beispiele==
===Arithmetisches Mittel berechnen===
Die folgende Tabelle zeigt ein Beispiel für eine Urliste. Die Stichprobe besteht aus den betrachteten Schülern. Es wird für das quantitative Merkmal Körpergröße in cm das arithmetische Mittel berechnet.
{| class="wikitable"
|-
! Schüler Nr.
| 1 || 2 || 3 || 4 || 5 || 6 || 7 || 8 || 9
|-
! Körpergröße in cm
| 183 || 172 || 163 || 154 || 158 || 166 || 177 || 188 || 190
|}

# Die Merkmalsausprägungen des Merkmals Körpergröße in cm sind die Werte 183, 172, 163, 154, 158, 166, 177, 188 und 190.
# Der Erhebungsumfang beträgt 9, da die Körpergröße von 9 Schülern erhoben wurde.
# Das arithmetische Mittel ist <math>\bar{x} = \frac{183 + 172 + 163 + 154 + 158 + 166 + 177 + 188 + 190}{9} \approx 172{,}33</math>.

Die Schüler in der Klasse sind durchschnittlich 172,33 cm groß.

===Arithmetisches Mittel mit Häufigkeiten berechnen===
Fügen wir noch einen 10. Schüler mit der Körpergröße 154 cm hinzu, so erhalten wir die folgende Urliste:
{| class="wikitable"
|-
! Schüler Nr.
| 1 || 2 || 3 || 4 || 5 || 6 || 7 || 8 || 9 || 10
|-
! Körpergröße in cm
| 183 || 172 || 163 || 154 || 158 || 166 || 177 || 188 || 190 || 154
|}

# Die Merkmalsausprägungen des Merkmals Körpergröße in cm sind die Werte 183, 172, 163, 154, 158, 166, 177, 188 und 190.
# Der Erhebungsumfang beträgt 10, da die Körpergröße von 10 Schülern erhoben wurde.
# Die absolute Häufigkeit der Merkmalsausprägung 154 ist 2, da zwei Schüler 154 cm groß sind.
# Die absoluten Häufigkeiten der restlichen Merkmalsausprägungen sind 1, da jede andere Körpergröße nur genau einmal vorkommt.
# Das arithmetische Mittel ist <math>\bar{x} = \frac{183 + 172 + 163 + 2 \cdot 154 + 158 + 166 + 177 + 188 + 190}{10} = 170{,}5</math>.

Da ein kleiner Schüler hinzugekommen ist, sind die Schüler in der Klasse durchschnittlich nur noch 170,5 cm groß.

[[Kategorie:Statistik]]
[[Kategorie:FHR_WuV_Mathe]]
[[Kategorie:AHR_WuV_Mathe_GK]]

Zufallsexperiment

2026-09-18T08:25:06Z

Flbkwikiadmin: /* Definition */

In der Wahrscheinlichkeitsrechnung werden Zufallsexperimente analysiert und auf Basis von Berechnungen werden Wahrscheinlichkeiten für die unterschiedlichen Ausgänge des Zufallsexperiments angegeben. Zufallsexperimente werden mit Hilfe von [[Baumdiagramm|Baumdiagrammen]] visualisiert.

==Definition==
In der Wahrscheinlichkeitsrechnung bezeichnet ein '''Zufallsexperiment''' einen Versuch, der unter genau festgelegten Versuchsbedingungen durchgeführt wird und einen zufälligen Ausgang hat. Die möglichen Ausgänge eines Zufallsexperimentes nennt man '''Ergebnisse'''. Wenn man alle möglichen Ergebnisse eines Zufallsexperimentes in einer [[Menge]] zusammenfasst, erhält man die '''Ergebnismenge'''. Die Ergebnismenge wird mit <math>S</math> oder <math>\Omega</math> bezeichnet.

<html><iframe width="280" height="157.5" src="https://www.youtube.com/embed/amHe2kAOfzA?si=78jb-3Gu5W26yF30" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe></html>

==Zufallsvariable==
Kann man den Ergebnissen eines Zufallsexperiments Zahlen zuordnen, so nennt man eine Variable für diese Zahlen '''Zufallsvariable'''. Zufallsvariablen werden häufig mit Großbuchstaben abgekürzt (z. B. X).

==Ereignis==
Ein Zufallsexperiment habe die Ergebnismenge <math>S</math>. Jede [[Menge#Teilmenge|Teilmenge]] <math>A</math> von <math>S</math> ist ein '''Ereignis'''. Endet die Durchführung des Zufallsexperiments mit einem Ergebnis aus <math>A</math>, so ist das Ereignis <math>A</math> eingetreten.
===Sicheres Ereignis===
Sei <math>S</math> die Ergebnismenge eines Zufallsexperiments und <math>E</math> ein Ereignis mit <math>S</math> = <math>E</math>, dann heißt <math>E</math> '''sicheres Ereignis'''.
===Unmögliches Ereignis===
Das Ereignis <math>F = \emptyset</math> heißt '''unmögliches Ereignis'''. <math>F</math> enthält also kein Ergebnis und ist damit die [[Menge#Leere_Menge|leere Menge]].
===Elementarereignis===
Gilt <math>G=\{{g}_1\}</math> bzw. <math>|G| = 1</math> für ein Ereignis <math>G</math>, so spricht man von einem '''Elementarereignis'''.
===Gegenereignis===
<math>\bar{H}</math> ist das '''Gegenereignis''' von <math>H</math>, d. h. es gilt <math>\bar{H}=S\ \setminus\ H</math> und <math>H\cup\bar{H}=S</math>.

==Beispiele==
===Zufallsexperiment Wurf eines Würfels===
Ein Würfel mit der Augenzahl von 1 bis 6 wird einmal geworfen und man beobachtet, welche Zahl oben liegt. Es handelt sich hierbei um ein Zufallsexperiment, da der Ausgang zufällig ist und der Versuch unter genau festgelegten Bedingungen stattfindet.
*Die Zufallsvariable <math>X</math> gibt die gewürfelte Augenzahl an. Beispielsweise bedeutet <math>X=3</math>, dass die Augenzahl 3 gewürfelt wurde.
*Ein mögliches Ergebnis: <math>3</math>
*Ergebnismenge: <math>S = \{1;2;3;4;5;6\}</math>
*Ereignis, dass keine 2 oder 3 gewürfelt wurde: <math>E = \{1;4;5;6\}</math>
*Sicheres Ereignis: <math>S</math>
*Unmögliches Ereignis: Es wurde eine 7 gewürfelt.
*Elementarereignis: <math>G=\{1\}</math>
*Gegenereignis zu <math>A = \{1;2\}</math>: <math>\bar{A} = \{3;4;5;6\}</math>

===Zufallsexperiment dreifacher Münzwurf===
Eine Münze wird dreimal geworfen und man beobachtet, in welcher Reihenfolge Zahl (Z) und Kopf (K) oben liegen. Es handelt sich hierbei um ein Zufallsexperiment, da der Ausgang zufällig ist und der Versuch unter genau festgelegten Bedingungen stattfindet.
*Ein Ergebnis ist <math>ZKZ</math>. Es wurde also im ersten Wurf Zahl, im zweiten Wurf Kopf und im dritten Wurf Zahl geworfen.
*Alle möglichen Ergebnisse werden durch die Ergebnismenge <math>S = \{ZZZ; ZZK; ZKZ; ZKK; KZZ; KZK; KKZ; KKK\}</math> beschrieben.
*Das Ereignis, dass kein Kopf erscheint, ist <math>A = \{ZZZ\}</math>.
*Das Ereignis, dass zwei- oder dreimal hintereinander Zahl erscheint, ist <math>B = \{ZZK; KZZ\}\cup \{ZZZ\} =\{ZZZ; ZZK; KZZ\}</math>.
*<math>S</math> ist dann auch das sichere Ereignis.
*Ein unmögliches Ereignis ist, dass bei jedem Wurf eine Blume kommt.
*<math>G=\{ZKZ\}</math> ist ein Elementarereignis.
*Das Gegenereignis <math>\bar{A}</math> von <math>A = \{ZZZ\}</math> ist <math>\bar{A} =S \backslash A=\{ZZZ; ZZK; ZKZ; ZKK; KZZ; KZK; KKZ; KKK\} \backslash \{ZZZ\}= \{ZZK; ZKZ; ZKK; KZZ; KZK; KKZ; KKK\}</math>.

[[Kategorie:Wahrscheinlichkeitsrechnung]]
[[Kategorie:FHR_WuV_Mathe]]
[[Kategorie:AHR_WuV_Mathe_GK]]

Kreisdiagramm

2026-09-17T06:37:37Z

Flbkwikiadmin:

[[Häufigkeit|Häufigkeiten]] von Merkmalsausprägungen aus statistischen [[H%C3%A4ufigkeit#Datenerhebung|Datenerhebungen]] können wir mit Hilfe von Diagrammen darstellen. Wir betrachten im Folgenden das Kreisdiagramm.

==Definition==
Zu einem [[H%C3%A4ufigkeit#Statistische_Begriffe|Merkmal]] aus einer [[H%C3%A4ufigkeit#Datenerhebung|Datenerhebung]] seien die [[Häufigkeit|Häufigkeiten]] der [[H%C3%A4ufigkeit#Statistische_Begriffe|Merkmalsausprägungen]] gegeben. In einem '''Kreisdiagramm''' werden die 360° des Kreises gemäß den relativen Häufigkeiten der Merkmalsausprägungen aufgeteilt. Alternativ kann der Kreis in so viele gleich große Teile geteilt werden, wie der Erhebungsumfang beträgt. Die absolute Häufigkeit einer Merkmalsausprägung für ein Objekt gibt dann an, wie viele Teile des Kreises belegt werden.

<html><iframe width="280" height="157.5" src="https://www.youtube.com/embed/UDd0EebVV9A?si=X-rpVq5oEb5UIWJW" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe></html>

==Beispiele==
===Ein Kreisdiagramm zeichnen===
Ein Würfel wurde 20 mal geworfen. In der folgenden Tabelle sind für das [[H%C3%A4ufigkeit#Statistische_Begriffe|Merkmal]] Würfelaugen die [[Häufigkeit|Häufigkeiten]] zu den [[H%C3%A4ufigkeit#Statistische_Begriffe|Merkmalsausprägungen]] 1, 2 ,3 ,4 ,5 ,6 festgehalten.
{| class="wikitable"
|-
! Würfelaugen
| 1 || 2 || 3 || 4 || 5 || 6
|-
! Absolute Häufigkeit
| 3 || 2 || 2 || 4 || 5 || 4
|-
! Relative Häufigkeit
| 0,15 || 0,1 || 0,1 || 0,2 || 0,25 || 0,2
|}

Die relative Häufigkeit der Augenzahl 1 beträgt 0,15, demnach müssen <math>0,15\cdot360\text{°}=54\text{°}</math> des Kreises markiert werden.

'''Alternativ''': Im obigen Würfelspiel wurde insgesamt 20 mal geworfen. Teilen wir den Kreis in 20 gleichgroße Teile auf, dann muss ein Teil einen Winkel von <math>\frac{1}{20}\cdot360\text{°}=18\text{°}</math> haben. Die absolute Häufigkeit der Augenzahl 1 beträgt 3, also werden dafür drei Teile des Kreises markiert. Insgesamt müssen also <math>18\text{°}\cdot 3=54\text{°}</math> des Kreises markiert werden.

Die Kreisdiagramme zum Würfelspiel sehen wie folgt aus:

<gallery heights=500px widths=400px>Datei:StatistikKreis.png|Kreisdiagramm für die Würfelergebnisse</gallery>

===Häufigkeiten aus einem Kreisdiagramm ablesen===
Die Größe eines Kreisausschnitts gibt die [[Häufigkeit]] an. Die [[H%C3%A4ufigkeit#Statistische_Begriffe|Merkmalsausprägung]] steht außerhalb des jeweiligen Kreisausschnitts. Die dazugehörige Häufigkeit steht im Kreisausschnitt. Beispielsweise lässt sich aus dem obigen Kreisdiagramm ablesen, dass die Augenzahl 3 insgesamt 2 mal gewürfelt wurde. Die relative Häufigkeit beträgt 0,1, d. h. 10 % der Würfe hatten die Augenzahl 3.

[[Kategorie:Statistik]]
[[Kategorie:FHR_WuV_Mathe]]
[[Kategorie:AHR_WuV_Mathe_GK]]

Flbkwiki:Impressum

2026-09-12T12:30:44Z

Flbkwikiadmin:

== Impressum ==

Angaben gemäß § 5 Digitale-Dienste-Gesetz (DDG)

=== Anbieter ===

Friedrich-List-Berufskolleg Hamm<br />
Vorheider Weg 14<br />
59067 Hamm

Telefon: 02381 91492-0<br />
E-Mail: info@bkfl.schulen-hamm.de<br />
Website: [https://www.flbk-hamm.de www.flbk-hamm.de]

=== Vertretungsberechtigung ===

Das Friedrich-List-Berufskolleg Hamm ist eine öffentliche Schule in der
Trägerschaft der Stadt Hamm und als solche eine nicht rechtsfähige
öffentliche Anstalt.

Vertreten durch: OStDin Dr. Heike Stiepelmann, Schulleiterin

=== Schulträger ===

Stadt Hamm

=== Zuständige Schulaufsichtsbehörde ===

Bezirksregierung Arnsberg

== Haftungsausschluss ==

=== Haftung für Inhalte ===

Die Inhalte dieses Wikis wurden mit größtmöglicher Sorgfalt für den
Unterrichtsgebrauch erstellt. Für die Richtigkeit, Vollständigkeit und
Aktualität der Inhalte kann jedoch keine Gewähr übernommen werden.

Die hier bereitgestellten Materialien dienen der Unterstützung des
Unterrichts. Sie ersetzen weder den Unterricht selbst noch die
verbindlichen Vorgaben der jeweiligen Lehrpläne, Bildungspläne oder
Prüfungsordnungen. Verbindlich sind ausschließlich die im Unterricht
bekannt gegebenen Inhalte und Regelungen.

=== Haftung für Links ===

Dieses Wiki enthält Links zu externen Websites Dritter, auf deren Inhalte
kein Einfluss besteht. Für diese fremden Inhalte kann keine Gewähr
übernommen werden; verantwortlich ist stets der jeweilige Anbieter oder
Betreiber der verlinkten Seiten. Die verlinkten Seiten wurden zum
Zeitpunkt der Verlinkung auf mögliche Rechtsverstöße überprüft;
rechtswidrige Inhalte waren nicht erkennbar. Eine dauerhafte inhaltliche
Kontrolle verlinkter Seiten ist ohne konkrete Anhaltspunkte einer
Rechtsverletzung nicht zumutbar. Bei Bekanntwerden von Rechtsverletzungen
werden entsprechende Links umgehend entfernt.

=== Urheberrecht ===

Die durch die Betreiber erstellten Inhalte und Werke auf diesen Seiten
unterliegen dem deutschen Urheberrecht.

Sollten Sie der Auffassung sein, dass Inhalte dieses Wikis Rechte Dritter
verletzen, wird um einen entsprechenden Hinweis gebeten. Bei Kenntnis von
Rechtsverletzungen werden die betroffenen Inhalte umgehend entfernt.

Flbkwiki:Datenschutz

2026-09-12T12:30:13Z

Flbkwikiadmin:

== Datenschutzerklärung ==

=== 1. Verantwortlicher ===

Verantwortlich für die Datenverarbeitung auf dieser Website im Sinne der
Datenschutz-Grundverordnung (DSGVO) ist:

Friedrich-List-Berufskolleg Hamm<br />
Vorheider Weg 14<br />
59067 Hamm

Telefon: 02381 91492-0<br />
E-Mail: info@bkfl.schulen-hamm.de<br />
Website: [https://www.flbk-hamm.de www.flbk-hamm.de]

Vertreten durch: OStDin Dr. Heike Stiepelmann, Schulleiterin

=== 2. Datenschutzbeauftragte/r ===

Sie können sich auch an den durch das Schulamt für die Stadt Hamm bestellten, behördlichen Datenschutzbeauftragten für die Hammer Schulen wenden: <br>
Telefon: +49(0)2381914246 <br>
Fax: +49(0)2381956486 <br>
E-Mail: datenschutzbeauftragter@schulen-hamm.de

=== 3. Zweck und Rechtsgrundlage der Verarbeitung ===

Dieses Wiki dient ausschließlich der Bereitstellung von Unterrichts- und
Lernmaterial für Schülerinnen, Schüler und Lehrkräfte des
Friedrich-List-Berufskollegs Hamm.

Rechtsgrundlage der Verarbeitung ist Art. 6 Abs. 1 lit. e DSGVO
(Wahrnehmung einer Aufgabe im öffentlichen Interesse) in Verbindung mit
den einschlägigen Vorschriften des Schulgesetzes NRW und des
Datenschutzgesetzes NRW.

=== 4. Server-Logdateien ===

Beim Aufruf dieser Website werden durch den Webserver automatisch
Informationen erfasst und in sogenannten Logdateien gespeichert:

* IP-Adresse des zugreifenden Geräts
* Datum und Uhrzeit des Zugriffs
* Name und URL der abgerufenen Datei
* verwendeter Browser und ggf. das Betriebssystem
* übertragene Datenmenge und Meldung über den Erfolg des Abrufs

Diese Daten sind technisch erforderlich, um die Website auszuliefern,
ihre Stabilität und Sicherheit zu gewährleisten und Angriffsversuche zu
erkennen. Eine Zusammenführung dieser Daten mit anderen Datenquellen
oder eine Auswertung zu Zwecken der Analyse des Nutzerverhaltens findet
nicht statt.

Die Logdateien werden nach spätestens 14 Tagen automatisch
gelöscht.

=== 5. Keine Registrierung, keine Konten für Schülerinnen und Schüler ===

Für das Lesen der Inhalte ist keine Anmeldung erforderlich. Eine
Registrierung durch Besucherinnen und Besucher ist technisch nicht
möglich. Benutzerkonten bestehen ausschließlich für redaktionell
tätige Lehrkräfte und werden durch die Administration angelegt.

Bei angemeldeten Benutzerinnen und Benutzern werden Benutzername,
E-Mail-Adresse (sofern angegeben) sowie die vorgenommenen Bearbeitungen
gespeichert. Bearbeitungen sind in der Versionsgeschichte der jeweiligen
Seite dauerhaft nachvollziehbar.

=== 6. Cookies ===

Diese Website setzt keine Cookies zu Analyse-, Werbe- oder
Tracking-Zwecken ein.

Beim Anmeldevorgang angemeldeter Benutzerinnen und Benutzer werden
technisch notwendige Sitzungs-Cookies gesetzt, die für die
Aufrechterhaltung der Anmeldung erforderlich sind. Diese werden nach
Ende der Sitzung bzw. nach Abmeldung gelöscht.

=== 7. Keine externen Dienste, keine Drittanbieter-Inhalte ===

Sämtliche für die Darstellung erforderlichen Komponenten – einschließlich
der Bibliotheken zur Darstellung mathematischer Formeln und interaktiver
Grafiken – werden ausschließlich vom eigenen Server ausgeliefert. Es
werden keine Inhalte von externen Content-Delivery-Netzwerken nachgeladen.
Beim Aufruf dieser Website werden daher keine Verbindungen zu
Drittanbietern hergestellt.

Es kommen keine Analyse-, Tracking- oder Reichweitenmessungsdienste und
keine Social-Media-Plugins zum Einsatz.

=== 8. Verschlüsselung ===

Diese Website wird ausschließlich verschlüsselt über HTTPS ausgeliefert,
um die Übertragung der Daten gegen Mitlesen durch Dritte zu schützen.

=== 9. Externe Links ===

Dieses Wiki enthält Links zu externen Websites. Beim Anklicken eines
solchen Links verlassen Sie diese Website; für die Datenverarbeitung auf
den Zielseiten ist ausschließlich der jeweilige Anbieter verantwortlich.
Es wird empfohlen, die dortigen Datenschutzhinweise zu beachten.

=== 10. Auftragsverarbeitung ===

Der technische Betrieb dieser Website erfolgt bei IONOS SE. Mit dem Anbieter besteht ein Vertrag zur
Auftragsverarbeitung gemäß Art. 28 DSGVO.

Datensicherungen werden innerhalb der schulischen Infrastruktur
gespeichert.

=== 11. Ihre Rechte ===

Sie haben gegenüber dem Verantwortlichen die folgenden Rechte
hinsichtlich der Sie betreffenden personenbezogenen Daten:

* Recht auf Auskunft (Art. 15 DSGVO)
* Recht auf Berichtigung (Art. 16 DSGVO)
* Recht auf Löschung (Art. 17 DSGVO)
* Recht auf Einschränkung der Verarbeitung (Art. 18 DSGVO)
* Recht auf Widerspruch gegen die Verarbeitung (Art. 21 DSGVO)
* Recht auf Datenübertragbarkeit (Art. 20 DSGVO)

Zur Ausübung dieser Rechte wenden Sie sich bitte an die oben genannten
Kontaktdaten.

=== 12. Beschwerderecht bei der Aufsichtsbehörde ===

Unabhängig davon steht Ihnen ein Beschwerderecht bei einer
Datenschutz-Aufsichtsbehörde zu. Zuständig ist:

Landesbeauftragte für Datenschutz und Informationsfreiheit
Nordrhein-Westfalen<br />
Kavalleriestraße 2-4, 40213 Düsseldorf<br />
[https://www.ldi.nrw.de/ https://www.ldi.nrw.de/]

=== 13. Änderungen dieser Datenschutzerklärung ===

Diese Datenschutzerklärung wird angepasst, sobald Änderungen an der
Website oder an den rechtlichen Rahmenbedingungen dies erforderlich
machen.

MediaWiki:Copyright

2026-09-12T12:27:47Z

Flbkwikiadmin: Die Seite wurde neu angelegt: „Der Inhalt ist verfügbar unter $1, sofern nicht anders angegeben.“

Der Inhalt ist verfügbar unter $1, sofern nicht anders angegeben.

Flbkwiki:Datenschutz

2026-09-12T12:21:34Z

Flbkwikiadmin:

== Datenschutzerklärung ==

=== 1. Verantwortlicher ===

Verantwortlich für die Datenverarbeitung auf dieser Website im Sinne der
Datenschutz-Grundverordnung (DSGVO) ist:

Friedrich-List-Berufskolleg Hamm<br />
Vorheider Weg 14<br />
59067 Hamm

Telefon: 02381 91492-0<br />
E-Mail: info@bkfl.schulen-hamm.de<br />
Website: [https://www.flbk-hamm.de www.flbk-hamm.de] Vertreten durch: OStDin Dr. Heike Stiepelmann, Schulleiter/in.

=== 2. Datenschutzbeauftragte/r ===

Sie können sich auch an den durch das Schulamt für die Stadt Hamm bestellten, behördlichen Datenschutzbeauftragten für die Hammer Schulen wenden: <br>
Telefon: +49(0)2381914246 <br>
Fax: +49(0)2381956486 <br>
E-Mail: datenschutzbeauftragter@schulen-hamm.de

=== 3. Zweck und Rechtsgrundlage der Verarbeitung ===

Dieses Wiki dient ausschließlich der Bereitstellung von Unterrichts- und
Lernmaterial für Schülerinnen, Schüler und Lehrkräfte des
Friedrich-List-Berufskollegs Hamm.

Rechtsgrundlage der Verarbeitung ist Art. 6 Abs. 1 lit. e DSGVO
(Wahrnehmung einer Aufgabe im öffentlichen Interesse) in Verbindung mit
den einschlägigen Vorschriften des Schulgesetzes NRW und des
Datenschutzgesetzes NRW.

=== 4. Server-Logdateien ===

Beim Aufruf dieser Website werden durch den Webserver automatisch
Informationen erfasst und in sogenannten Logdateien gespeichert:

* IP-Adresse des zugreifenden Geräts
* Datum und Uhrzeit des Zugriffs
* Name und URL der abgerufenen Datei
* verwendeter Browser und ggf. das Betriebssystem
* übertragene Datenmenge und Meldung über den Erfolg des Abrufs

Diese Daten sind technisch erforderlich, um die Website auszuliefern,
ihre Stabilität und Sicherheit zu gewährleisten und Angriffsversuche zu
erkennen. Eine Zusammenführung dieser Daten mit anderen Datenquellen
oder eine Auswertung zu Zwecken der Analyse des Nutzerverhaltens findet
nicht statt.

Die Logdateien werden nach spätestens 14 Tagen automatisch
gelöscht.

=== 5. Keine Registrierung, keine Konten für Schülerinnen und Schüler ===

Für das Lesen der Inhalte ist keine Anmeldung erforderlich. Eine
Registrierung durch Besucherinnen und Besucher ist technisch nicht
möglich. Benutzerkonten bestehen ausschließlich für redaktionell
tätige Lehrkräfte und werden durch die Administration angelegt.

Bei angemeldeten Benutzerinnen und Benutzern werden Benutzername,
E-Mail-Adresse (sofern angegeben) sowie die vorgenommenen Bearbeitungen
gespeichert. Bearbeitungen sind in der Versionsgeschichte der jeweiligen
Seite dauerhaft nachvollziehbar.

=== 6. Cookies ===

Diese Website setzt keine Cookies zu Analyse-, Werbe- oder
Tracking-Zwecken ein.

Beim Anmeldevorgang angemeldeter Benutzerinnen und Benutzer werden
technisch notwendige Sitzungs-Cookies gesetzt, die für die
Aufrechterhaltung der Anmeldung erforderlich sind. Diese werden nach
Ende der Sitzung bzw. nach Abmeldung gelöscht.

=== 7. Keine externen Dienste, keine Drittanbieter-Inhalte ===

Sämtliche für die Darstellung erforderlichen Komponenten – einschließlich
der Bibliotheken zur Darstellung mathematischer Formeln und interaktiver
Grafiken – werden ausschließlich vom eigenen Server ausgeliefert. Es
werden keine Inhalte von externen Content-Delivery-Netzwerken nachgeladen.
Beim Aufruf dieser Website werden daher keine Verbindungen zu
Drittanbietern hergestellt.

Es kommen keine Analyse-, Tracking- oder Reichweitenmessungsdienste und
keine Social-Media-Plugins zum Einsatz.

=== 8. Verschlüsselung ===

Diese Website wird ausschließlich verschlüsselt über HTTPS ausgeliefert,
um die Übertragung der Daten gegen Mitlesen durch Dritte zu schützen.

=== 9. Externe Links ===

Dieses Wiki enthält Links zu externen Websites. Beim Anklicken eines
solchen Links verlassen Sie diese Website; für die Datenverarbeitung auf
den Zielseiten ist ausschließlich der jeweilige Anbieter verantwortlich.
Es wird empfohlen, die dortigen Datenschutzhinweise zu beachten.

=== 10. Auftragsverarbeitung ===

Der technische Betrieb dieser Website erfolgt bei IONOS SE. Mit dem Anbieter besteht ein Vertrag zur
Auftragsverarbeitung gemäß Art. 28 DSGVO.

Datensicherungen werden innerhalb der schulischen Infrastruktur
gespeichert.

=== 11. Ihre Rechte ===

Sie haben gegenüber dem Verantwortlichen die folgenden Rechte
hinsichtlich der Sie betreffenden personenbezogenen Daten:

* Recht auf Auskunft (Art. 15 DSGVO)
* Recht auf Berichtigung (Art. 16 DSGVO)
* Recht auf Löschung (Art. 17 DSGVO)
* Recht auf Einschränkung der Verarbeitung (Art. 18 DSGVO)
* Recht auf Widerspruch gegen die Verarbeitung (Art. 21 DSGVO)
* Recht auf Datenübertragbarkeit (Art. 20 DSGVO)

Zur Ausübung dieser Rechte wenden Sie sich bitte an die oben genannten
Kontaktdaten.

=== 12. Beschwerderecht bei der Aufsichtsbehörde ===

Unabhängig davon steht Ihnen ein Beschwerderecht bei einer
Datenschutz-Aufsichtsbehörde zu. Zuständig ist:

Landesbeauftragte für Datenschutz und Informationsfreiheit
Nordrhein-Westfalen<br />
Kavalleriestraße 2-4, 40213 Düsseldorf-Stadtbezirk 3<br />
[https://www.ldi.nrw.de/ https://www.ldi.nrw.de/]

=== 13. Änderungen dieser Datenschutzerklärung ===

Diese Datenschutzerklärung wird angepasst, sobald Änderungen an der
Website oder an den rechtlichen Rahmenbedingungen dies erforderlich
machen.

Flbkwiki:Datenschutz

2026-09-12T12:20:18Z

Flbkwikiadmin:

== Datenschutzerklärung ==

=== 1. Verantwortlicher ===

Verantwortlich für die Datenverarbeitung auf dieser Website im Sinne der
Datenschutz-Grundverordnung (DSGVO) ist:

Friedrich-List-Berufskolleg Hamm<br />
Vorheider Weg 14<br />
59067 Hamm

Telefon: 02381 91492-0<br />
E-Mail: info@bkfl.schulen-hamm.de<br />
Website: [https://www.flbk-hamm.de www.flbk-hamm.de] vertreten durch die Schulleitung.

=== 2. Datenschutzbeauftragte/r ===

Sie können sich auch an den durch das Schulamt für die Stadt Hamm bestellten, behördlichen Datenschutzbeauftragten für die Hammer Schulen wenden: <br>
Telefon: +49(0)2381914246 <br>
Fax: +49(0)2381956486 <br>
E-Mail: datenschutzbeauftragter@schulen-hamm.de

=== 3. Zweck und Rechtsgrundlage der Verarbeitung ===

Dieses Wiki dient ausschließlich der Bereitstellung von Unterrichts- und
Lernmaterial für Schülerinnen, Schüler und Lehrkräfte des
Friedrich-List-Berufskollegs Hamm.

Rechtsgrundlage der Verarbeitung ist Art. 6 Abs. 1 lit. e DSGVO
(Wahrnehmung einer Aufgabe im öffentlichen Interesse) in Verbindung mit
den einschlägigen Vorschriften des Schulgesetzes NRW und des
Datenschutzgesetzes NRW.

=== 4. Server-Logdateien ===

Beim Aufruf dieser Website werden durch den Webserver automatisch
Informationen erfasst und in sogenannten Logdateien gespeichert:

* IP-Adresse des zugreifenden Geräts
* Datum und Uhrzeit des Zugriffs
* Name und URL der abgerufenen Datei
* verwendeter Browser und ggf. das Betriebssystem
* übertragene Datenmenge und Meldung über den Erfolg des Abrufs

Diese Daten sind technisch erforderlich, um die Website auszuliefern,
ihre Stabilität und Sicherheit zu gewährleisten und Angriffsversuche zu
erkennen. Eine Zusammenführung dieser Daten mit anderen Datenquellen
oder eine Auswertung zu Zwecken der Analyse des Nutzerverhaltens findet
nicht statt.

Die Logdateien werden nach spätestens 14 Tagen automatisch
gelöscht.

=== 5. Keine Registrierung, keine Konten für Schülerinnen und Schüler ===

Für das Lesen der Inhalte ist keine Anmeldung erforderlich. Eine
Registrierung durch Besucherinnen und Besucher ist technisch nicht
möglich. Benutzerkonten bestehen ausschließlich für redaktionell
tätige Lehrkräfte und werden durch die Administration angelegt.

Bei angemeldeten Benutzerinnen und Benutzern werden Benutzername,
E-Mail-Adresse (sofern angegeben) sowie die vorgenommenen Bearbeitungen
gespeichert. Bearbeitungen sind in der Versionsgeschichte der jeweiligen
Seite dauerhaft nachvollziehbar.

=== 6. Cookies ===

Diese Website setzt keine Cookies zu Analyse-, Werbe- oder
Tracking-Zwecken ein.

Beim Anmeldevorgang angemeldeter Benutzerinnen und Benutzer werden
technisch notwendige Sitzungs-Cookies gesetzt, die für die
Aufrechterhaltung der Anmeldung erforderlich sind. Diese werden nach
Ende der Sitzung bzw. nach Abmeldung gelöscht.

=== 7. Keine externen Dienste, keine Drittanbieter-Inhalte ===

Sämtliche für die Darstellung erforderlichen Komponenten – einschließlich
der Bibliotheken zur Darstellung mathematischer Formeln und interaktiver
Grafiken – werden ausschließlich vom eigenen Server ausgeliefert. Es
werden keine Inhalte von externen Content-Delivery-Netzwerken nachgeladen.
Beim Aufruf dieser Website werden daher keine Verbindungen zu
Drittanbietern hergestellt.

Es kommen keine Analyse-, Tracking- oder Reichweitenmessungsdienste und
keine Social-Media-Plugins zum Einsatz.

=== 8. Verschlüsselung ===

Diese Website wird ausschließlich verschlüsselt über HTTPS ausgeliefert,
um die Übertragung der Daten gegen Mitlesen durch Dritte zu schützen.

=== 9. Externe Links ===

Dieses Wiki enthält Links zu externen Websites. Beim Anklicken eines
solchen Links verlassen Sie diese Website; für die Datenverarbeitung auf
den Zielseiten ist ausschließlich der jeweilige Anbieter verantwortlich.
Es wird empfohlen, die dortigen Datenschutzhinweise zu beachten.

=== 10. Auftragsverarbeitung ===

Der technische Betrieb dieser Website erfolgt bei IONOS SE. Mit dem Anbieter besteht ein Vertrag zur
Auftragsverarbeitung gemäß Art. 28 DSGVO.

Datensicherungen werden innerhalb der schulischen Infrastruktur
gespeichert.

=== 11. Ihre Rechte ===

Sie haben gegenüber dem Verantwortlichen die folgenden Rechte
hinsichtlich der Sie betreffenden personenbezogenen Daten:

* Recht auf Auskunft (Art. 15 DSGVO)
* Recht auf Berichtigung (Art. 16 DSGVO)
* Recht auf Löschung (Art. 17 DSGVO)
* Recht auf Einschränkung der Verarbeitung (Art. 18 DSGVO)
* Recht auf Widerspruch gegen die Verarbeitung (Art. 21 DSGVO)
* Recht auf Datenübertragbarkeit (Art. 20 DSGVO)

Zur Ausübung dieser Rechte wenden Sie sich bitte an die oben genannten
Kontaktdaten.

=== 12. Beschwerderecht bei der Aufsichtsbehörde ===

Unabhängig davon steht Ihnen ein Beschwerderecht bei einer
Datenschutz-Aufsichtsbehörde zu. Zuständig ist:

Landesbeauftragte für Datenschutz und Informationsfreiheit
Nordrhein-Westfalen<br />
Kavalleriestraße 2-4, 40213 Düsseldorf-Stadtbezirk 3<br />
[https://www.ldi.nrw.de/ https://www.ldi.nrw.de/]

=== 13. Änderungen dieser Datenschutzerklärung ===

Diese Datenschutzerklärung wird angepasst, sobald Änderungen an der
Website oder an den rechtlichen Rahmenbedingungen dies erforderlich
machen.

Flbkwiki:Datenschutz

2026-09-12T12:15:41Z

Flbkwikiadmin:

== Datenschutzerklärung ==

=== 1. Verantwortlicher ===

Verantwortlich für die Datenverarbeitung auf dieser Website im Sinne der
Datenschutz-Grundverordnung (DSGVO) ist:

Friedrich-List-Berufskolleg Hamm<br />
Vorheider Weg 14<br />
59067 Hamm

Telefon: 02381 91492-0<br />
E-Mail: info@bkfl.schulen-hamm.de<br />
Website: [https://www.flbk-hamm.de www.flbk-hamm.de] vertreten durch die Schulleitung.

=== 2. Zweck und Rechtsgrundlage der Verarbeitung ===

Dieses Wiki dient ausschließlich der Bereitstellung von Unterrichts- und
Lernmaterial für Schülerinnen, Schüler und Lehrkräfte des
Friedrich-List-Berufskollegs Hamm.

Rechtsgrundlage der Verarbeitung ist Art. 6 Abs. 1 lit. e DSGVO
(Wahrnehmung einer Aufgabe im öffentlichen Interesse) in Verbindung mit
den einschlägigen Vorschriften des Schulgesetzes NRW und des
Datenschutzgesetzes NRW.

=== 3. Server-Logdateien ===

Beim Aufruf dieser Website werden durch den Webserver automatisch
Informationen erfasst und in sogenannten Logdateien gespeichert:

* IP-Adresse des zugreifenden Geräts
* Datum und Uhrzeit des Zugriffs
* Name und URL der abgerufenen Datei
* verwendeter Browser und ggf. das Betriebssystem
* übertragene Datenmenge und Meldung über den Erfolg des Abrufs

Diese Daten sind technisch erforderlich, um die Website auszuliefern,
ihre Stabilität und Sicherheit zu gewährleisten und Angriffsversuche zu
erkennen. Eine Zusammenführung dieser Daten mit anderen Datenquellen
oder eine Auswertung zu Zwecken der Analyse des Nutzerverhaltens findet
nicht statt.

Die Logdateien werden nach spätestens 14 Tagen automatisch
gelöscht.

=== 4. Keine Registrierung, keine Konten für Schülerinnen und Schüler ===

Für das Lesen der Inhalte ist keine Anmeldung erforderlich. Eine
Registrierung durch Besucherinnen und Besucher ist technisch nicht
möglich. Benutzerkonten bestehen ausschließlich für redaktionell
tätige Lehrkräfte und werden durch die Administration angelegt.

Bei angemeldeten Benutzerinnen und Benutzern werden Benutzername,
E-Mail-Adresse (sofern angegeben) sowie die vorgenommenen Bearbeitungen
gespeichert. Bearbeitungen sind in der Versionsgeschichte der jeweiligen
Seite dauerhaft nachvollziehbar.

=== 5. Cookies ===

Diese Website setzt keine Cookies zu Analyse-, Werbe- oder
Tracking-Zwecken ein.

Beim Anmeldevorgang angemeldeter Benutzerinnen und Benutzer werden
technisch notwendige Sitzungs-Cookies gesetzt, die für die
Aufrechterhaltung der Anmeldung erforderlich sind. Diese werden nach
Ende der Sitzung bzw. nach Abmeldung gelöscht.

=== 6. Keine externen Dienste, keine Drittanbieter-Inhalte ===

Sämtliche für die Darstellung erforderlichen Komponenten – einschließlich
der Bibliotheken zur Darstellung mathematischer Formeln und interaktiver
Grafiken – werden ausschließlich vom eigenen Server ausgeliefert. Es
werden keine Inhalte von externen Content-Delivery-Netzwerken nachgeladen.
Beim Aufruf dieser Website werden daher keine Verbindungen zu
Drittanbietern hergestellt.

Es kommen keine Analyse-, Tracking- oder Reichweitenmessungsdienste und
keine Social-Media-Plugins zum Einsatz.

=== 7. Verschlüsselung ===

Diese Website wird ausschließlich verschlüsselt über HTTPS ausgeliefert,
um die Übertragung der Daten gegen Mitlesen durch Dritte zu schützen.

=== 8. Externe Links ===

Dieses Wiki enthält Links zu externen Websites. Beim Anklicken eines
solchen Links verlassen Sie diese Website; für die Datenverarbeitung auf
den Zielseiten ist ausschließlich der jeweilige Anbieter verantwortlich.
Es wird empfohlen, die dortigen Datenschutzhinweise zu beachten.

=== 9. Auftragsverarbeitung ===

Der technische Betrieb dieser Website erfolgt bei IONOS SE. Mit dem Anbieter besteht ein Vertrag zur
Auftragsverarbeitung gemäß Art. 28 DSGVO.

Datensicherungen werden innerhalb der schulischen Infrastruktur
gespeichert.

=== 10. Ihre Rechte ===

Sie haben gegenüber dem Verantwortlichen die folgenden Rechte
hinsichtlich der Sie betreffenden personenbezogenen Daten:

* Recht auf Auskunft (Art. 15 DSGVO)
* Recht auf Berichtigung (Art. 16 DSGVO)
* Recht auf Löschung (Art. 17 DSGVO)
* Recht auf Einschränkung der Verarbeitung (Art. 18 DSGVO)
* Recht auf Widerspruch gegen die Verarbeitung (Art. 21 DSGVO)
* Recht auf Datenübertragbarkeit (Art. 20 DSGVO)

Zur Ausübung dieser Rechte wenden Sie sich bitte an die oben genannten
Kontaktdaten.

=== 11. Beschwerderecht bei der Aufsichtsbehörde ===

Unabhängig davon steht Ihnen ein Beschwerderecht bei einer
Datenschutz-Aufsichtsbehörde zu. Zuständig ist:

Landesbeauftragte für Datenschutz und Informationsfreiheit
Nordrhein-Westfalen<br />
Kavalleriestraße 2-4, 40213 Düsseldorf-Stadtbezirk 3<br />
[https://www.ldi.nrw.de/ https://www.ldi.nrw.de/]

=== 12. Änderungen dieser Datenschutzerklärung ===

Diese Datenschutzerklärung wird angepasst, sobald Änderungen an der
Website oder an den rechtlichen Rahmenbedingungen dies erforderlich
machen.

Flbkwiki:Datenschutz

2026-09-12T12:09:56Z

Flbkwikiadmin:

== Datenschutzerklärung ==

=== 1. Verantwortlicher ===

Verantwortlich für die Datenverarbeitung auf dieser Website im Sinne der
Datenschutz-Grundverordnung (DSGVO) ist:

Friedrich-List-Berufskolleg Hamm<br />
Vorheider Weg 14<br />
59067 Hamm

Telefon: 02381 91492-0<br />
E-Mail: info@bkfl.schulen-hamm.de<br />
Website: [https://www.flbk-hamm.de www.flbk-hamm.de]
vertreten durch die Schulleitung.

=== 2. Zweck und Rechtsgrundlage der Verarbeitung ===

Dieses Wiki dient ausschließlich der Bereitstellung von Unterrichts- und
Lernmaterial für Schülerinnen, Schüler und Lehrkräfte des
Friedrich-List-Berufskollegs Hamm.

Rechtsgrundlage der Verarbeitung ist Art. 6 Abs. 1 lit. e DSGVO
(Wahrnehmung einer Aufgabe im öffentlichen Interesse) in Verbindung mit
den einschlägigen Vorschriften des Schulgesetzes NRW und des
Datenschutzgesetzes NRW.

=== 3. Server-Logdateien ===

Beim Aufruf dieser Website werden durch den Webserver automatisch
Informationen erfasst und in sogenannten Logdateien gespeichert:

* IP-Adresse des zugreifenden Geräts
* Datum und Uhrzeit des Zugriffs
* Name und URL der abgerufenen Datei
* verwendeter Browser und ggf. das Betriebssystem
* übertragene Datenmenge und Meldung über den Erfolg des Abrufs

Diese Daten sind technisch erforderlich, um die Website auszuliefern,
ihre Stabilität und Sicherheit zu gewährleisten und Angriffsversuche zu
erkennen. Eine Zusammenführung dieser Daten mit anderen Datenquellen
oder eine Auswertung zu Zwecken der Analyse des Nutzerverhaltens findet
nicht statt.

Die Logdateien werden nach spätestens 14 Tagen automatisch
gelöscht.

=== 4. Keine Registrierung, keine Konten für Schülerinnen und Schüler ===

Für das Lesen der Inhalte ist keine Anmeldung erforderlich. Eine
Registrierung durch Besucherinnen und Besucher ist technisch nicht
möglich. Benutzerkonten bestehen ausschließlich für redaktionell
tätige Lehrkräfte und werden durch die Administration angelegt.

Bei angemeldeten Benutzerinnen und Benutzern werden Benutzername,
E-Mail-Adresse (sofern angegeben) sowie die vorgenommenen Bearbeitungen
gespeichert. Bearbeitungen sind in der Versionsgeschichte der jeweiligen
Seite dauerhaft nachvollziehbar.

=== 5. Cookies ===

Diese Website setzt keine Cookies zu Analyse-, Werbe- oder
Tracking-Zwecken ein.

Beim Anmeldevorgang angemeldeter Benutzerinnen und Benutzer werden
technisch notwendige Sitzungs-Cookies gesetzt, die für die
Aufrechterhaltung der Anmeldung erforderlich sind. Diese werden nach
Ende der Sitzung bzw. nach Abmeldung gelöscht.

=== 6. Keine externen Dienste, keine Drittanbieter-Inhalte ===

Sämtliche für die Darstellung erforderlichen Komponenten – einschließlich
der Bibliotheken zur Darstellung mathematischer Formeln und interaktiver
Grafiken – werden ausschließlich vom eigenen Server ausgeliefert. Es
werden keine Inhalte von externen Content-Delivery-Netzwerken nachgeladen.
Beim Aufruf dieser Website werden daher keine Verbindungen zu
Drittanbietern hergestellt.

Es kommen keine Analyse-, Tracking- oder Reichweitenmessungsdienste und
keine Social-Media-Plugins zum Einsatz.

=== 7. Verschlüsselung ===

Diese Website wird ausschließlich verschlüsselt über HTTPS ausgeliefert,
um die Übertragung der Daten gegen Mitlesen durch Dritte zu schützen.

=== 8. Externe Links ===

Dieses Wiki enthält Links zu externen Websites. Beim Anklicken eines
solchen Links verlassen Sie diese Website; für die Datenverarbeitung auf
den Zielseiten ist ausschließlich der jeweilige Anbieter verantwortlich.
Es wird empfohlen, die dortigen Datenschutzhinweise zu beachten.

=== 9. Auftragsverarbeitung ===

Der technische Betrieb dieser Website erfolgt bei IONOS SE. Mit dem Anbieter besteht ein Vertrag zur
Auftragsverarbeitung gemäß Art. 28 DSGVO.

Datensicherungen werden innerhalb der schulischen Infrastruktur
gespeichert.

=== 10. Ihre Rechte ===

Sie haben gegenüber dem Verantwortlichen die folgenden Rechte
hinsichtlich der Sie betreffenden personenbezogenen Daten:

* Recht auf Auskunft (Art. 15 DSGVO)
* Recht auf Berichtigung (Art. 16 DSGVO)
* Recht auf Löschung (Art. 17 DSGVO)
* Recht auf Einschränkung der Verarbeitung (Art. 18 DSGVO)
* Recht auf Widerspruch gegen die Verarbeitung (Art. 21 DSGVO)
* Recht auf Datenübertragbarkeit (Art. 20 DSGVO)

Zur Ausübung dieser Rechte wenden Sie sich bitte an die oben genannten
Kontaktdaten.

=== 11. Beschwerderecht bei der Aufsichtsbehörde ===

Unabhängig davon steht Ihnen ein Beschwerderecht bei einer
Datenschutz-Aufsichtsbehörde zu. Zuständig ist:

Landesbeauftragte für Datenschutz und Informationsfreiheit
Nordrhein-Westfalen<br />
Kavalleriestraße 2-4, 40213 Düsseldorf-Stadtbezirk 3<br />
[https://www.ldi.nrw.de/ https://www.ldi.nrw.de/]

=== 12. Änderungen dieser Datenschutzerklärung ===

Diese Datenschutzerklärung wird angepasst, sobald Änderungen an der
Website oder an den rechtlichen Rahmenbedingungen dies erforderlich
machen.

Flbkwiki:Über FLBK-Wiki

2026-09-12T11:54:53Z

Flbkwikiadmin:

== Über das FLBK-Wiki ==

=== Zweck ===

Das FLBK-Wiki ist ein Nachschlagewerk für Unterrichtsinhalte des
Friedrich-List-Berufskollegs Hamm. Es sammelt Definitionen, Sätze,
Beispiele und Erläuterungen aus den Fächern Mathematik und Informatik
und stellt sie dauerhaft und geräteunabhängig zur Verfügung.

Das Wiki richtet sich in erster Linie an die Schülerinnen und Schüler
der Bildungsgänge des Berufskollegs. Es kann zur Vor- und Nachbereitung
des Unterrichts, zur Wiederholung und zur Prüfungsvorbereitung genutzt
werden.

=== Abgrenzung zu anderen Angeboten ===

Das Wiki dient ausschließlich der '''Darstellung''' von Inhalten. Es
enthält keine Aufgaben, Tests oder Leistungsüberprüfungen.

Übungsaufgaben, Lernkontrollen, Materialien zu einzelnen Kursen sowie
alle organisatorischen Inhalte finden sich auf der Lernplattform der
Schule unter [https://elearning.flbk-hamm.de elearning.flbk-hamm.de].

=== Redaktion und Mitarbeit ===

Die Inhalte werden ausschließlich von Lehrkräften der Schule erstellt und
gepflegt. Eine Bearbeitung durch Schülerinnen und Schüler ist nicht
vorgesehen; eine Registrierung ist nicht möglich.

Hinweise auf Fehler, unklare Formulierungen oder fehlende Themen sind
ausdrücklich willkommen und können an [E-Mail-Adresse oder „die
jeweilige Lehrkraft“] gerichtet werden.

=== Verbindlichkeit der Inhalte ===

Die Inhalte dieses Wikis werden mit Sorgfalt erstellt, erheben aber
keinen Anspruch auf Vollständigkeit. Verbindlich für Unterricht und
Prüfungen sind ausschließlich die im Unterricht behandelten Inhalte
sowie die geltenden Lehrpläne und Prüfungsordnungen.

=== Nutzung der Inhalte ===

Die Inhalte dürfen von Schülerinnen, Schülern und Lehrkräften der Schule
zu Unterrichts- und Lernzwecken frei genutzt werden. Eine darüber
hinausgehende Verwendung, insbesondere eine Veröffentlichung oder
kommerzielle Nutzung, bedarf der vorherigen Zustimmung.

=== Technischer Hinweis ===

Dieses Wiki basiert auf der freien Software
[https://www.mediawiki.org MediaWiki].

=== Rechtliche Hinweise ===

* [[Flbkwiki:Impressum|Impressum und Haftungsausschluss]]
* [[Flbkwiki:Datenschutz|Datenschutzerklärung]]

Flbkwiki:Über FLBK-Wiki

2026-09-12T11:54:47Z

Flbkwikiadmin: Die Seite wurde neu angelegt: „== Über das FLBK-Wiki == === Zweck === Das FLBK-Wiki ist ein Nachschlagewerk für Unterrichtsinhalte des Friedrich-List-Berufskollegs Hamm. Es sammelt Definitionen, Sätze, Beispiele und Erläuterungen aus den Fächern Mathematik und Informatik und stellt sie dauerhaft und geräteunabhängig zur Verfügung. Das Wiki richtet sich in erster Linie an die Schülerinnen und Schüler der Bildungsgänge des Berufskollegs. Es kann zur Vor- und Nachbereitung d…“

Flbkwiki:Datenschutz

2026-09-12T11:53:14Z

Flbkwikiadmin: Die Seite wurde neu angelegt: „== Datenschutzerklärung == === 1. Verantwortlicher === Verantwortlich für die Datenverarbeitung auf dieser Website im Sinne der Datenschutz-Grundverordnung (DSGVO) ist: Friedrich-List-Berufskolleg Hamm<br /> Vorheider Weg 14<br /> 59067 Hamm Telefon: 02381 91492-0<br /> E-Mail: info@bkfl.schulen-hamm.de<br /> Website: [https://www.flbk-hamm.de www.flbk-hamm.de] vertreten durch die Schulleitung. === 2. Zweck und Rechtsgrundlage der Verarbeitung ===…“

== Datenschutzerklärung ==

=== 1. Verantwortlicher ===

Verantwortlich für die Datenverarbeitung auf dieser Website im Sinne der
Datenschutz-Grundverordnung (DSGVO) ist:

Friedrich-List-Berufskolleg Hamm<br />
Vorheider Weg 14<br />
59067 Hamm

Telefon: 02381 91492-0<br />
E-Mail: info@bkfl.schulen-hamm.de<br />
Website: [https://www.flbk-hamm.de www.flbk-hamm.de]
vertreten durch die Schulleitung.

=== 2. Zweck und Rechtsgrundlage der Verarbeitung ===

Dieses Wiki dient ausschließlich der Bereitstellung von Unterrichts- und
Lernmaterial für Schülerinnen, Schüler und Lehrkräfte des
Friedrich-List-Berufskollegs Hamm.

Rechtsgrundlage der Verarbeitung ist Art. 6 Abs. 1 lit. e DSGVO
(Wahrnehmung einer Aufgabe im öffentlichen Interesse) in Verbindung mit
den einschlägigen Vorschriften des Schulgesetzes NRW und des
Datenschutzgesetzes NRW.

=== 3. Server-Logdateien ===

Beim Aufruf dieser Website werden durch den Webserver automatisch
Informationen erfasst und in sogenannten Logdateien gespeichert:

* IP-Adresse des zugreifenden Geräts
* Datum und Uhrzeit des Zugriffs
* Name und URL der abgerufenen Datei
* verwendeter Browser und ggf. das Betriebssystem
* übertragene Datenmenge und Meldung über den Erfolg des Abrufs

Diese Daten sind technisch erforderlich, um die Website auszuliefern,
ihre Stabilität und Sicherheit zu gewährleisten und Angriffsversuche zu
erkennen. Eine Zusammenführung dieser Daten mit anderen Datenquellen
oder eine Auswertung zu Zwecken der Analyse des Nutzerverhaltens findet
nicht statt.

Die Logdateien werden nach spätestens [Anzahl] Tagen automatisch
gelöscht.

=== 4. Keine Registrierung, keine Konten für Schülerinnen und Schüler ===

Für das Lesen der Inhalte ist keine Anmeldung erforderlich. Eine
Registrierung durch Besucherinnen und Besucher ist technisch nicht
möglich. Benutzerkonten bestehen ausschließlich für redaktionell
tätige Lehrkräfte und werden durch die Administration angelegt.

Bei angemeldeten Benutzerinnen und Benutzern werden Benutzername,
E-Mail-Adresse (sofern angegeben) sowie die vorgenommenen Bearbeitungen
gespeichert. Bearbeitungen sind in der Versionsgeschichte der jeweiligen
Seite dauerhaft nachvollziehbar.

=== 5. Cookies ===

Diese Website setzt keine Cookies zu Analyse-, Werbe- oder
Tracking-Zwecken ein.

Beim Anmeldevorgang angemeldeter Benutzerinnen und Benutzer werden
technisch notwendige Sitzungs-Cookies gesetzt, die für die
Aufrechterhaltung der Anmeldung erforderlich sind. Diese werden nach
Ende der Sitzung bzw. nach Abmeldung gelöscht.

=== 6. Keine externen Dienste, keine Drittanbieter-Inhalte ===

Sämtliche für die Darstellung erforderlichen Komponenten – einschließlich
der Bibliotheken zur Darstellung mathematischer Formeln und interaktiver
Grafiken – werden ausschließlich vom eigenen Server ausgeliefert. Es
werden keine Inhalte von externen Content-Delivery-Netzwerken nachgeladen.
Beim Aufruf dieser Website werden daher keine Verbindungen zu
Drittanbietern hergestellt.

Es kommen keine Analyse-, Tracking- oder Reichweitenmessungsdienste und
keine Social-Media-Plugins zum Einsatz.

=== 7. Verschlüsselung ===

Diese Website wird ausschließlich verschlüsselt über HTTPS ausgeliefert,
um die Übertragung der Daten gegen Mitlesen durch Dritte zu schützen.

=== 8. Externe Links ===

Dieses Wiki enthält Links zu externen Websites. Beim Anklicken eines
solchen Links verlassen Sie diese Website; für die Datenverarbeitung auf
den Zielseiten ist ausschließlich der jeweilige Anbieter verantwortlich.
Es wird empfohlen, die dortigen Datenschutzhinweise zu beachten.

=== 9. Auftragsverarbeitung ===

Der technische Betrieb dieser Website erfolgt bei [Name des
Hosting-Anbieters]. Mit dem Anbieter besteht ein Vertrag zur
Auftragsverarbeitung gemäß Art. 28 DSGVO.

Datensicherungen werden innerhalb der schulischen Infrastruktur
gespeichert.

=== 10. Ihre Rechte ===

Sie haben gegenüber dem Verantwortlichen die folgenden Rechte
hinsichtlich der Sie betreffenden personenbezogenen Daten:

* Recht auf Auskunft (Art. 15 DSGVO)
* Recht auf Berichtigung (Art. 16 DSGVO)
* Recht auf Löschung (Art. 17 DSGVO)
* Recht auf Einschränkung der Verarbeitung (Art. 18 DSGVO)
* Recht auf Widerspruch gegen die Verarbeitung (Art. 21 DSGVO)
* Recht auf Datenübertragbarkeit (Art. 20 DSGVO)

Zur Ausübung dieser Rechte wenden Sie sich bitte an die oben genannten
Kontaktdaten.

=== 11. Beschwerderecht bei der Aufsichtsbehörde ===

Unabhängig davon steht Ihnen ein Beschwerderecht bei einer
Datenschutz-Aufsichtsbehörde zu. Zuständig ist:

Landesbeauftragte für Datenschutz und Informationsfreiheit
Nordrhein-Westfalen<br />
[Anschrift]<br />
[Website]

=== 12. Änderungen dieser Datenschutzerklärung ===

Diese Datenschutzerklärung wird angepasst, sobald Änderungen an der
Website oder an den rechtlichen Rahmenbedingungen dies erforderlich
machen.

Flbkwiki:Impressum

2026-09-12T11:51:28Z

Flbkwikiadmin: Die Seite wurde neu angelegt: „== Impressum == Angaben gemäß § 5 Digitale-Dienste-Gesetz (DDG) === Anbieter === Friedrich-List-Berufskolleg Hamm<br /> Vorheider Weg 14<br /> 59067 Hamm Telefon: 02381 91492-0<br /> E-Mail: info@bkfl.schulen-hamm.de<br /> Website: [https://www.flbk-hamm.de www.flbk-hamm.de] === Vertretungsberechtigung === Das Friedrich-List-Berufskolleg Hamm ist eine öffentliche Schule in der Trägerschaft der Stadt Hamm und als solche eine nicht rechtsfähige…“

== Impressum ==

Angaben gemäß § 5 Digitale-Dienste-Gesetz (DDG)

=== Anbieter ===

Friedrich-List-Berufskolleg Hamm<br />
Vorheider Weg 14<br />
59067 Hamm

Telefon: 02381 91492-0<br />
E-Mail: info@bkfl.schulen-hamm.de<br />
Website: [https://www.flbk-hamm.de www.flbk-hamm.de]

=== Vertretungsberechtigung ===

Das Friedrich-List-Berufskolleg Hamm ist eine öffentliche Schule in der
Trägerschaft der Stadt Hamm und als solche eine nicht rechtsfähige
öffentliche Anstalt.

Vertreten durch: Schulleiter/in

=== Schulträger ===

Stadt Hamm

=== Zuständige Schulaufsichtsbehörde ===

Bezirksregierung Arnsberg

== Haftungsausschluss ==

=== Haftung für Inhalte ===

Die Inhalte dieses Wikis wurden mit größtmöglicher Sorgfalt für den
Unterrichtsgebrauch erstellt. Für die Richtigkeit, Vollständigkeit und
Aktualität der Inhalte kann jedoch keine Gewähr übernommen werden.

Die hier bereitgestellten Materialien dienen der Unterstützung des
Unterrichts. Sie ersetzen weder den Unterricht selbst noch die
verbindlichen Vorgaben der jeweiligen Lehrpläne, Bildungspläne oder
Prüfungsordnungen. Verbindlich sind ausschließlich die im Unterricht
bekannt gegebenen Inhalte und Regelungen.

=== Haftung für Links ===

Dieses Wiki enthält Links zu externen Websites Dritter, auf deren Inhalte
kein Einfluss besteht. Für diese fremden Inhalte kann keine Gewähr
übernommen werden; verantwortlich ist stets der jeweilige Anbieter oder
Betreiber der verlinkten Seiten. Die verlinkten Seiten wurden zum
Zeitpunkt der Verlinkung auf mögliche Rechtsverstöße überprüft;
rechtswidrige Inhalte waren nicht erkennbar. Eine dauerhafte inhaltliche
Kontrolle verlinkter Seiten ist ohne konkrete Anhaltspunkte einer
Rechtsverletzung nicht zumutbar. Bei Bekanntwerden von Rechtsverletzungen
werden entsprechende Links umgehend entfernt.

=== Urheberrecht ===

Die durch die Betreiber erstellten Inhalte und Werke auf diesen Seiten
unterliegen dem deutschen Urheberrecht.

Sollten Sie der Auffassung sein, dass Inhalte dieses Wikis Rechte Dritter
verletzen, wird um einen entsprechenden Hinweis gebeten. Bei Kenntnis von
Rechtsverletzungen werden die betroffenen Inhalte umgehend entfernt.

MediaWiki:Disclaimers

2026-09-12T11:46:13Z

Flbkwikiadmin: Die Seite wurde neu angelegt: „Impressum & Haftungsausschluss“

Impressum & Haftungsausschluss

Stapel

2026-09-11T06:59:16Z

Flbkwikiadmin:

== Einführung ==
In der Informatik bezeichnet ein '''Stapelspeicher''' oder '''Kellerspeicher''' (kurz ''Stapel'' oder ''Keller'', häufig auch mit dem englischen Fachbegriff '''Stack''' bezeichnet) eine fundamentale, dynamische Datenstruktur. Sie dient der temporären Zwischenspeicherung von Datenobjekten in einer streng definierten Reihenfolge und ist ein zentraler Bestandteil der objektorientierten Anwendungsentwicklung.

Objekte der abstrakten Datenstruktur (ADT) <code>Stack</code> verwalten beliebige Elemente nach dem '''LIFO-Prinzip''' (''Last-In-First-Out''). Das bedeutet: Das Element, welches als letztes auf den Stapel gelegt wurde, wird als erstes wieder entnommen.

'''Alltagsanalogie:'''
Ein Kellerspeicher lässt sich anschaulich mit einem Stapel von Umzugskisten oder einem Tellerstapel vergleichen. Es kann immer nur eine neue Kiste oben auf den Stapel gepackt werden (dies entspricht der Operation <code>push</code>). Ebenso kann immer nur die oberste Kiste heruntergenommen werden (entspricht der Operation <code>pop</code>). Der lesende oder schreibende Zugriff ist strukturell zwingend auf das oberste Element des Stapels beschränkt. Ein Hinzufügen oder Entfernen einer Kiste weiter unten im Stapel ist nicht möglich.

== Visualisierung ==
Die Arbeitsweise der LIFO-Datenstruktur lässt sich durch die beiden Hauptoperationen – das Hinzufügen (Push) und das Entfernen (Pop) – am Kopfende des Stapels veranschaulichen.

<html>
<svg width="500" height="360" viewBox="0 0 500 360" xmlns="http://www.w3.org/2000/svg" style="background-color: transparent;">

<defs>
<marker id="arrow-push" viewBox="0 0 10 10" refX="5" refY="5" markerWidth="6" markerHeight="6" orient="auto">
<path d="M 0 0 L 10 5 L 0 10 z" fill="#000000"/>
</marker>
<marker id="arrow-pop" viewBox="0 0 10 10" refX="5" refY="5" markerWidth="6" markerHeight="6" orient="auto">
<path d="M 0 0 L 10 5 L 0 10 z" fill="#000000"/>
</marker>
</defs>


<rect x="200" y="300" width="100" height="35" fill="#e0e0ff" stroke="#000000" stroke-width="1"/>
<rect x="200" y="260" width="100" height="35" fill="#c0c0ff" stroke="#000000" stroke-width="1"/>
<rect x="200" y="220" width="100" height="35" fill="#a0a0ff" stroke="#000000" stroke-width="1"/>
<rect x="200" y="180" width="100" height="35" fill="#8080ff" stroke="#000000" stroke-width="1"/>
<rect x="200" y="140" width="100" height="35" fill="#6060ff" stroke="#000000" stroke-width="1"/>
<rect x="200" y="100" width="100" height="35" fill="#4040ff" stroke="#000000" stroke-width="1"/>


<rect x="40" y="20" width="100" height="35" fill="#4040ff" stroke="#000000" stroke-width="1"/>
<text x="120" y="85" font-family="Arial, sans-serif" font-size="22" fill="#000000">Push</text>

<path d="M 140 60 Q 190 60 195 90" fill="none" stroke="#000000" stroke-width="2" marker-end="url(#arrow-push)"/>


<rect x="360" y="20" width="100" height="35" fill="#4040ff" stroke="#000000" stroke-width="1"/>
<text x="310" y="85" font-family="Arial, sans-serif" font-size="22" fill="#000000">Pop</text>

<path d="M 260 85 Q 270 50 350 40" fill="none" stroke="#000000" stroke-width="2" marker-end="url(#arrow-pop)"/>
</svg>
</html>

== Aufbau und Spezifikation (API) ==
Im Kontext der Softwaretechnologie wird diese abstrakte Datenstruktur formal über eine wohldefinierte Schnittstelle abgebildet, um die Kapselung der Daten zu gewährleisten[cite: 4]. Ein klassischer Stapel verfügt über die folgenden Methoden und Konstruktoren:

=== Konstruktor ===
* <code>Stack()</code>
** Ein neuer, leerer Stapel wird erzeugt.

=== Methoden ===
* <code>boolean isEmpty()</code>
** Die Anfrage liefert den Wert <code>true</code>, wenn der Stapel keine Objekte enthält. Andernfalls liefert sie den Wert <code>false</code>.
* <code>void push(Object pObject)</code>
** Das Objekt <code>pObject</code> wird oben auf den Stapel gelegt. Falls <code>pObject</code> den Wert <code>null</code> hat, bleibt der Stapel unverändert.
* <code>void pop()</code>
** Das zuletzt eingefügte (oberste) Objekt wird von dem Stapel entfernt. Falls der Stapel bereits leer ist, bleibt er unverändert (es tritt kein Fehler auf).
* <code>Object top()</code>
** Die Anfrage liefert das oberste Stapelobjekt zurück, ohne es aus der Datenstruktur zu entfernen. Der Stapel bleibt unverändert. Falls der Stapel leer ist, wird <code>null</code> zurückgegeben.

== Laufzeitanalyse (Komplexität) ==
Eine effiziente Implementierung des Stacks (beispielsweise über eine einfach verkettete Liste, bei der stets am Kopfknoten eingefügt und gelöscht wird) garantiert hochperformante Zugriffszeiten. Da ausschließlich auf das oberste Element zugegriffen wird, müssen keine iterativen Suchvorgänge durchgeführt oder nachfolgende Elemente im Speicher verschoben werden. Es ergibt sich gemäß der [[Landau-Symbole|Landau-Notation]] folgende Laufzeitkomplexität:

{| class="wikitable" style="text-align:center;"
|-
! Operation !! 1. Best-Case !! 2. Average-Case !! 3. Worst-Case
|-
| <code>push(Object pObject)</code> || <math>\mathcal{O}(1)</math> || <math>\mathcal{O}(1)</math> || <math>\mathcal{O}(1)</math>
|-
| <code>pop()</code> || <math>\mathcal{O}(1)</math> || <math>\mathcal{O}(1)</math> || <math>\mathcal{O}(1)</math>
|-
| <code>top()</code> || <math>\mathcal{O}(1)</math> || <math>\mathcal{O}(1)</math> || <math>\mathcal{O}(1)</math>
|-
| <code>isEmpty()</code> || <math>\mathcal{O}(1)</math> || <math>\mathcal{O}(1)</math> || <math>\mathcal{O}(1)</math>
|}

== Beispiel: Arbeitsweise der Stack-Operationen ==
Die Veränderung des inneren Zustands eines Stacks lässt sich anhand einer sequenziellen Abfolge von Operationen nachvollziehen. In der folgenden Tabelle ist das jeweils oberste Element (Top) der Liste rechts angeordnet.

{| class="wikitable"
|-
! Schritt !! Operation !! Zustand des Stacks (Bottom → Top) !! Erläuterung
|-
| 1. || <code>Stack()</code> || <code>[ ]</code> (leer) || Nach Aufruf des Konstruktors ist der Stack initialisiert, enthält aber noch keine Elemente.
|-
| 2. || <code>push(12)</code> || <code>[12]</code> || Nach Aufruf von <code>push(12)</code> enthält der Stack genau ein Element, nämlich die Zahl 12.
|-
| 3. || <code>push(8)</code> || <code>[12, 8]</code> || Nach Aufruf von <code>push(8)</code> sind zwei Elemente im Stack enthalten. Die 8 wurde zuletzt hinzugefügt, befindet sich also oben im Stack.
|-
| 4. || <code>pop()</code> || <code>[12]</code> || Wenn <code>pop()</code> aufgerufen wird, wird die 8 wieder entfernt – sie war die zuletzt hinzugefügte Zahl.
|-
| 5. || <code>push(15)</code> || <code>[12, 15]</code> || Nach <code>push(15)</code> besteht der Stack wieder aus zwei Elementen. Die 15 wurde zuletzt gepusht, liegt also oben auf dem Stack.
|-
| 6. || <code>push(16)</code> || <code>[12, 15, 16]</code> || Nach <code>push(16)</code> besteht der Stack aus drei Elementen. Wieder ist die zuletzt gepushte Zahl ganz oben im Stack. Ein Aufruf von <code>top()</code> würde nun <code>16</code> zurückgeben.
|}

== Implementierungsbeispiel (Java) ==
Für das tiefergehende Verständnis im Informatikunterricht ist nachfolgend eine klassische objektorientierte Implementierung des Stacks auf Basis einer einfach verketteten Liste (Knotenstruktur) dargestellt. Diese Implementierung ermöglicht das Anwenden dynamischer Datenstrukturen sowie die Untersuchung zur Effizienz und Korrektheit von Algorithmen[cite: 3].

<syntaxhighlight lang="java">
public class Stack {

// Verweis auf das oberste Element des Stapels
private Node head;

// Innere Knoten-Klasse zur Kapselung der Datenstruktur
private class Node {
Object content;
Node nextNode;

public Node(Object pContent) {
content = pContent;
nextNode = null;
}
}

/**
* Konstruktor: Ein leerer Stapel wird erzeugt.
*/
public Stack() {
head = null;
}

/**
* Prüft, ob der Stapel leer ist.
*/
public boolean isEmpty() {
return head == null;
}

/**
* Legt ein neues Objekt oben auf den Stapel.
*/
public void push(Object pObject) {
if (pObject != null) {
Node newNode = new Node(pObject);
newNode.nextNode = head; // Das neue Element zeigt auf den bisherigen Kopf
head = newNode; // Der Kopf wird auf das neue Element gesetzt
}
}

/**
* Entfernt das oberste Objekt vom Stapel.
*/
public void pop() {
if (!this.isEmpty()) {
head = head.nextNode; // Der Kopf rutscht ein Element nach unten (das alte Top-Element wird vom Garbage Collector entfernt)
}
}

/**
* Liefert das oberste Objekt des Stapels.
*/
public Object top() {
if (this.isEmpty()) {
return null;
} else {
return head.content;
}
}
}
</syntaxhighlight>

[[Kategorie:Programmierung]]
[[Kategorie:AHR I Informatik LK]]
[[Kategorie:FI I SDM]]

Dynamische Datenstruktur

2026-09-07T11:59:26Z

Flbkwikiadmin:

'''Dynamische Datenstrukturen''' sind in der [[Programmierung]] essenzielle Datenbehälter (Container) für [[Objekt]]e. Sie reservieren flexibel und zur Laufzeit des Programms Arbeitsspeicher und können somit eine theoretisch unbegrenzte Anzahl von Objekten aufnehmen. Im Gegensatz zu [[Array]]s (Datenfeldern), die eine statische, bei der Initialisierung festgelegte Länge besitzen, bieten dynamische Datenstrukturen die notwendige Flexibilität bei der Verwaltung variabler Datenmengen.

== Einführung ==
In komplexen Softwareanwendungen müssen häufig sehr viele Objekte verwaltet und effizient organisiert werden. Ein klassischer Behälter hierfür ist das [[Array]]. Da ein Array jedoch eine feste Größe besitzt, führt dies oft zu Speicherverschwendung (wenn das Array zu groß dimensioniert ist) oder zu Speicherfehlern (wenn das Array zu klein ist). Dynamische Datenstrukturen lösen dieses Problem, indem sie Mechanismen bereitstellen, um den reservierten Speicherplatz mit jeder hinzugefügten oder entfernten Dateneinheit dynamisch anzupassen[cite: 3].

Bekannte Beispiele für abstrakte, dynamische Datenstrukturen sind:
* [[Schlange]] (Queue)
* [[Stapel]] (Stack)
* [[Liste]] (List)

Der insgesamt reservierbare Arbeitsspeicher ist dabei lediglich durch die Systemressourcen und den verwendeten [[Datentyp]] begrenzt. In der beruflichen Praxis und der Anwendungsentwicklung ist es eine Kernkompetenz, die Effizienz und Einsatzmöglichkeiten dieser Strukturen analysieren und eigene, maßgeschneiderte Strukturen entwerfen zu können[cite: 4].

== Knoten als Basis dynamischer Strukturen ==
Während man einfache Listen auch mittels intern vergrößerbarer Arrays umsetzen kann, werden klassische dynamische Datenstrukturen häufig über '''Knoten''' (engl. ''Node'') realisiert.

Ein Knoten ist ein Instanzobjekt einer speziellen Klasse, das neben den eigentlichen Nutzdaten auch mindestens einen [[Zeiger]] (Referenz) auf einen anderen Knoten enthält. Durch diese Verkettung von Objekten im Arbeitsspeicher entsteht eine vernetzte Datenstruktur (z. B. eine verkettete Liste).
* Ein Zeiger kann auf einen konkreten Nachfolgeknoten verweisen.
* Ein Zeiger kann auf <code>null</code> (nichts) verweisen, was in der Regel das Ende der Struktur markiert.
* Mindestens ein Zeiger (meist <code>start</code>, <code>head</code> oder <code>root</code> genannt) muss im Hauptprogramm auf das erste Element verweisen, da die Struktur sonst vom ''Garbage Collector'' aus dem Speicher gelöscht wird.

Je nach Aufbau der Zeiger unterscheidet man verschiedene Arten von Knoten:

=== Unidirektionale Knoten ===
[[Datei:Unidirektionaler Knoten.png|mini|Schematische Darstellung eines unidirektionalen Knotens]]
Unidirektional (aus dem Lateinischen ''uni'' für „ein“) bedeutet, dass die Verkettung nur in eine einzige Richtung verläuft. Ein unidirektionaler Knoten speichert exakt eine Referenz auf seinen Nachfolger. Eine Navigation zurück zum Vorgänger ist in dieser Struktur nicht möglich.

=== Bidirektionale Knoten ===
[[Datei:Bidirektionaler Knoten.png|mini|Schematische Darstellung eines bidirektionalen Knotens]]
Ein bidirektionaler Knoten (lateinische Vorsilbe ''bi-'' für „zwei“) speichert Zeiger in zwei Richtungen. Er verweist sowohl auf seinen direkten Nachfolger als auch auf seinen direkten Vorgänger. Dies ermöglicht die Vorwärts- und Rückwärtsnavigation innerhalb der Datenstruktur, erfordert jedoch geringfügig mehr Arbeitsspeicher für den zusätzlichen Zeiger.

== Implementierungsbeispiel (Java) ==
Das folgende Beispiel veranschaulicht den Aufbau einer einfachen, unidirektional verketteten Liste in der objektorientierten Programmierung.

[[Datei:BlueJ Inspektion.png|mini|Darstellung der Objektverkettung im Speicher]]

Visuelle Repräsentation der verketteten Struktur (Knoten mit Daten und Zeiger):
<math>
meineListe \rightarrow \boxed{5}\boxed{\rightarrow}
\rightarrow \boxed{42}\boxed{\rightarrow}
\rightarrow \boxed{16}\boxed{\emptyset}
</math>

=== Die Knoten-Klasse ===
Diese Klasse definiert das Speicherobjekt. Sie beinhaltet die Nutzdaten und die Referenz auf das nächste Element.

<syntaxhighlight lang="java">
public class Knoten {

private double daten; // Nutzdaten, zum Beispiel 5.0 oder 42.0
private Knoten naechster; // Zeiger (Referenz) auf den nächsten Knoten

/**
* Standardkonstruktor: Erzeugt einen leeren Knoten.
*/
public Knoten() {
this.naechster = null; // Zeigt noch nirgendwo hin
}

/**
* Konstruktor zur direkten Übergabe von Nutzdaten.
*/
public Knoten(double pDaten) {
this.daten = pDaten;
this.naechster = null;
}

/**
* Konstruktor zur Übergabe von Daten und Setzen des Nachfolgers.
*/
public Knoten(double pDaten, Knoten pNext) {
this.daten = pDaten;
this.naechster = pNext;
}

// --- Getter- und Setter-Methoden zur Datenkapselung ---

public Knoten getNaechster() {
return this.naechster;
}

public void setNaechster(Knoten pNaechster) {
this.naechster = pNaechster;
}

public double getDaten() {
return this.daten;
}

public void setDaten(double pDaten) {
this.daten = pDaten;
}
}
</syntaxhighlight>

=== Die Listen-Klasse ===
Die verwaltende Klasse kapselt die Zugriffslogik und speichert den Startpunkt der Struktur.

<syntaxhighlight lang="java">
public class Liste {

private Knoten start; // Zeiger auf das erste Element der Liste

public Liste() {
this.start = null; // Eine neu erzeugte Liste ist anfangs leer
}

/**
* Testmethode zur manuellen Erzeugung und Verkettung von drei Knoten.
*/
public void testen() {
// 1. Startknoten als Platzhalter initialisieren
this.start = new Knoten();

// 2. Weitere Knoten mit Werten erzeugen
Knoten knoten1 = new Knoten(5.0);
Knoten knoten2 = new Knoten(16.0);
Knoten knoten3 = new Knoten(42.0);

// 3. Knotenlogik: Die Objekte miteinander verketten
this.start.setNaechster(knoten1);
knoten1.setNaechster(knoten2);
knoten2.setNaechster(knoten3);
// knoten3.getNaechster() ist weiterhin null und markiert das Listenende.
}

public Knoten getStart() {
return this.start;
}
}
</syntaxhighlight>

== Das Java Collection Framework ==
In der professionellen Softwareentwicklung (Software Engineering) müssen diese fundamentalen Datenstrukturen in der Regel nicht von Grund auf neu programmiert werden[cite: 3]. [[Java]] fasst fertig implementierte, typisierte und hochoptimierte Datenbehälter im '''Java Collection Framework''' zusammen.

Neben den eigentlichen Containern gehören hierzu auch mächtige Standardalgorithmen, wie beispielsweise effiziente [[Sortierverfahren]] oder Suchalgorithmen, die direkt auf den Containern operieren. Die Grundlage dieses Frameworks sind sogenannte Interfaces (Schnittstellen), die das Verhalten der Datencontainer vertraglich vorgeben.

* Die Klasse <code>java.util.ArrayList</code> ist beispielsweise eine in der Praxis extrem häufig genutzte dynamische Datenstruktur, die das <code>List</code>-Interface (ein Sub-Interface der Oberschnittstelle <code>Collection</code>) implementiert.
* In der flexiblen Listenstruktur der <code>ArrayList</code> können zur Laufzeit beliebig viele Objekte hinzugefügt und auch wieder entfernt werden, da sich die Datenstruktur im Hintergrund selbstständig vergrößert oder verkleinert.

[[Kategorie:Programmierung]]
[[Kategorie:FI I SDM]]
[[Kategorie:FI I TP1]]
[[Kategorie:AHR I Informatik LK]]

Mehrschichten Architektur

2026-09-07T06:52:31Z

Flbkwikiadmin: Die Seite wurde neu angelegt: „== Einführung == Die '''Schichtenarchitektur''' (auch ''Schichtenmodell'' oder ''Schichtenmuster'') ist ein grundlegendes und häufig angewandtes Strukturierungsprinzip für die Architektur von Softwaresystemen. Dabei werden einzelne Aspekte des Softwaresystems konzeptionell einer spezifischen Schicht (engl. ''tier'' oder ''layer'') zugeordnet. Ein zentrales Prinzip dieses Modells ist die '''unidirektionale Abhängigkeit''': Eine höhere Schicht greift…“

== Einführung ==
Die '''Schichtenarchitektur''' (auch ''Schichtenmodell'' oder ''Schichtenmuster'') ist ein grundlegendes und häufig angewandtes Strukturierungsprinzip für die Architektur von Softwaresystemen. Dabei werden einzelne Aspekte des Softwaresystems konzeptionell einer spezifischen Schicht (engl. ''tier'' oder ''layer'') zugeordnet.

Ein zentrales Prinzip dieses Modells ist die '''unidirektionale Abhängigkeit''': Eine höhere Schicht greift immer nur auf die Dienste der direkt darunterliegenden Schicht zu. Die niedrigere Schicht fungiert somit als Dienstanbieter (Server) für die höhere Schicht (Client). Die den Schichten zugeordneten Aspekte können je nach Art des Systems oder Detaillierungsgrad der Betrachtung beispielsweise Funktionalitäten, Hard- und Software-Komponenten oder einzelne Klassen sein.

Ziel der Schichtenarchitektur ist die Entkopplung von Systemkomponenten (''Separation of Concerns''), was die Wartbarkeit, Austauschbarkeit und Erweiterbarkeit von Software erheblich verbessert.

== Zwei-Schichten-Architektur ==
Für einen relativ groben Detaillierungsgrad lässt sich beispielsweise die klassische [[Client-Server-Architektur]] als Zwei-Schichten-Architektur (''Two-Tier Architecture'') beschreiben. Ein Client nutzt dabei die Dienste eines Servers.

'''Beispiel aus der Netzwerktechnik:'''
In einem lokalen Netzwerk (LAN) werden Arbeitsplatzrechner (Clients) genutzt, um Daten einzugeben oder abzufragen. Diese Rechner speichern ihre Daten nicht lokal, sondern auf einem zentralen Server. Der Server bietet das Speichern und Abrufen der Daten als Dienst an, greift aber von sich aus nicht aktiv auf die Clients zu. Die Clients hingegen initiieren die Kommunikation und nutzen den Dienst des Servers.

Eine Client-Server-Architektur muss jedoch nicht zwingend über unterschiedliche physische Rechner (Hardware) realisiert werden. Vielmehr kann der Client auch als reines Software-Modul verstanden werden, das auf ein zweites Software-Modul – beispielsweise ein lokales [[Datenbankmanagementsystem]] (DBMS) – auf demselben Rechner innerhalb derselben Anwendung zugreift.

== Drei-Schichten-Architektur ==
Eine dreischichtige Architektur (''Three-Tier Architecture'') erlaubt eine deutlich detailliertere und professionellere Strukturierung eines Softwaresystems. Im Gegensatz zur zweischichtigen Architektur existiert hier eine zusätzliche vermittelnde Schicht, die sogenannte Logikschicht. Dies verhindert, dass die Benutzeroberfläche direkt mit der Datenbank kommuniziert.

Eine typische Drei-Schichten-Architektur besteht aus den folgenden drei Schichten:

* '''Präsentationsschicht (Presentation Layer):'''
** Sie ist ausschließlich für die grafische Darstellung der Daten und die Erfassung von Benutzereingaben (GUI) verantwortlich.
** Sie enthält keine Anwendungslogik. Realisiert wird diese Schicht in der Praxis beispielsweise durch Frameworks wie Java-Swing, JavaFX oder durch HTML/CSS in Webanwendungen.
* '''Logikschicht (Business Logic Layer / Application Layer):'''
** Sie bildet das Herzstück der Anwendung und beinhaltet alle Geschäftsobjekte sowie die automatisierten Prozesse zur Datenverarbeitung.
** Sie nimmt die Eingaben der Präsentationsschicht entgegen, verarbeitet diese nach definierten Geschäftsregeln und leitet sie an die Datenhaltung weiter. Realisiert wird sie in der Regel durch [[Objektorientierte Programmierung|objektorientierte Programmiersprachen]] wie Java oder C#.
* '''Datenhaltungsschicht (Data Layer):'''
** Diese Schicht ist isoliert für das dauerhafte Speichern (Persistenz), Ändern und Laden von Daten verantwortlich.
** Für rudimentäre Anwendungen kann das Speichern in einfachen Text- oder XML-Dateien auf der Festplatte erfolgen. Für professionelle und komplexe Anwendungen wird standardmäßig der Einsatz eines [[Datenbankmanagementsystem|Datenbankmanagementsystems]] (z. B. MySQL, PostgreSQL) vorausgesetzt.

== Fazit und architektonische Bedeutung ==
Die Drei-Schichten-Architektur lässt sich systematisch innerhalb des Software-Engineerings umsetzen. Software-Module werden strikt für die Präsentation, die Anwendungslogik und die dauerhafte Speicherung von Daten vorgesehen und gemäß der Schichteneinteilung voneinander entkoppelt.

[[Datei:DBMS-Schichten.png|mini]]
Ändert sich beispielsweise das Datenbanksystem (Datenhaltungsschicht), müssen die Präsentations- und Logikschicht im Idealfall nicht angepasst werden. Eine solche Drei-Schichten-Architektur gilt in der professionellen Anwendungsentwicklung üblicherweise als das Mindestmaß architektonischer Strukturierung, sofern keine zwingenden Gründe (z. B. bei hochkomplexen Microservices) für andere Architekturentscheidungen vorliegen.

[[Kategorie:Modellierung]]
[[Kategorie:AHR I Informatik LK]]
[[Kategorie:FI I SDM]]

Liste

2026-09-04T08:48:02Z

Flbkwikiadmin: Die Seite wurde neu angelegt: „== Einführung == In der Informatik ist die '''verkettete Liste''' (englisch ''Linked List'') oder kurz '''Liste''' eine fundamentale dynamische Datenstruktur. Sie dient der sequenziellen Speicherung von logisch zusammengehörigen, aber physisch im Speicher verstreuten Datenobjekten[cite: 3]. Im Gegensatz zu statischen Datenstrukturen (wie dem Array) müssen die einzelnen Elemente einer Liste im Arbeitsspeicher nicht direkt hintereinanderliegen. Die log…“

== Einführung ==
In der Informatik ist die '''verkettete Liste''' (englisch ''Linked List'') oder kurz '''Liste''' eine fundamentale dynamische Datenstruktur. Sie dient der sequenziellen Speicherung von logisch zusammengehörigen, aber physisch im Speicher verstreuten Datenobjekten[cite: 3].

Im Gegensatz zu statischen Datenstrukturen (wie dem Array) müssen die einzelnen Elemente einer Liste im Arbeitsspeicher nicht direkt hintereinanderliegen. Die logische Reihenfolge wird stattdessen durch '''Zeiger (Referenzen)''' realisiert, die von einem Listenelement zum nächsten weisen. Ein einzelnes Element der Liste wird als '''Knoten''' (englisch ''Node'') bezeichnet. Jeder Knoten kapselt die eigentlichen Nutzdaten (den Inhalt) und besitzt mindestens einen Zeiger auf seinen direkten Nachfolger. Man unterscheidet hierbei zwischen unidirektionalen (einfach verketteten) und bidirektionalen (doppelt verketteten) Listen.

Objekte der abstrakten Datenstruktur <code>List</code> verwalten beliebig viele, linear angeordnete Objekte. Das wesentliche Konzept der im nordrhein-westfälischen Abitur verwendeten Listenstruktur ist das '''aktuelle Objekt''' (''Current''): Auf höchstens ein Listenobjekt kann zu einem gegebenen Zeitpunkt direkt lesend oder schreibend zugegriffen werden.
Wenn eine Liste leer ist, der Durchlauf das Ende überschritten hat oder das aktuelle Objekt gelöscht wurde, ist die Referenz auf das aktuelle Objekt ungültig (<code>null</code>). Das Setzen des aktuellen Objekts erfolgt über definierte Navigationsmethoden.

=== Vorteile und Nachteile gegenüber einem Array ===
* '''Vorteil:''' Das Einfügen und Löschen von Elementen an der aktuellen Position ist in konstanter Zeit (<math>\mathcal{O}(1)</math>) möglich, da lediglich Zeiger umgebogen werden müssen. Es ist nicht notwendig, nachfolgende Elemente im Speicher zu verschieben. Zudem wächst die Liste dynamisch mit ihren Anforderungen (keine feste Größenbegrenzung).
* '''Nachteil:''' Die Liste verbraucht mehr Speicherplatz (Overhead durch die Speicherung der Referenzzeiger). Zudem ist kein direkter Indexzugriff möglich; um das <math>n</math>-te Element zu finden, muss die Liste von vorne durchlaufen werden.

== Visualisierung ==
Die nachfolgende Abbildung veranschaulicht eine einfach verkettete (unidirektionale) Liste. Das eigentliche Listen-Objekt (hier als Dreieck dargestellt) verwaltet den Zustand der Liste über zwei interne Zeiger: einen Referenzzeiger auf das allererste Element (''Startknoten'') und einen Referenzzeiger auf das aktuell fokussierte Element (''Aktueller Knoten'').

<html>
<svg width="700" height="350" viewBox="0 0 700 350" xmlns="http://www.w3.org/2000/svg" style="background-color: transparent; font-family: Arial, sans-serif;">

<text x="350" y="30" font-size="22" font-weight="bold" text-anchor="middle" fill="#222222">Liste mit unidirektionalen Knoten</text>


<defs>
<marker id="arrow-black" viewBox="0 0 10 10" refX="8" refY="5" markerWidth="6" markerHeight="6" orient="auto">
<path d="M 0 0 L 10 5 L 0 10 z" fill="#000000"/>
</marker>
</defs>


<polygon points="100,100 20,240 180,240" fill="#d0e0ff" stroke="#000000" stroke-width="1.5" />
<text x="100" y="200" font-size="14" text-anchor="middle" fill="#222222">Knoten start</text>
<text x="100" y="225" font-size="14" text-anchor="middle" fill="#222222">Knoten aktuell</text>


<rect x="260" y="150" width="90" height="70" fill="#b0c4de" stroke="#000000" stroke-width="1.5" />
<text x="305" y="175" font-size="14" text-anchor="middle" fill="#222222">Knoten A</text>
<line x1="260" y1="190" x2="350" y2="190" stroke="#000000" stroke-width="1" />
<text x="305" y="210" font-size="14" text-anchor="middle" fill="#222222">Zahl = 16</text>


<rect x="420" y="150" width="90" height="70" fill="#b0c4de" stroke="#000000" stroke-width="1.5" />
<text x="465" y="175" font-size="14" text-anchor="middle" fill="#222222">Knoten B</text>
<line x1="420" y1="190" x2="510" y2="190" stroke="#000000" stroke-width="1" />
<text x="465" y="210" font-size="14" text-anchor="middle" fill="#222222">Zahl = 5</text>


<rect x="580" y="150" width="90" height="70" fill="#b0c4de" stroke="#000000" stroke-width="1.5" />
<text x="625" y="175" font-size="14" text-anchor="middle" fill="#222222">Knoten C</text>
<line x1="580" y1="190" x2="670" y2="190" stroke="#000000" stroke-width="1" />
<text x="625" y="210" font-size="14" text-anchor="middle" fill="#222222">Zahl = 42</text>


<line x1="350" y1="185" x2="410" y2="185" stroke="#000000" stroke-width="2" marker-end="url(#arrow-black)" />
<line x1="510" y1="185" x2="570" y2="185" stroke="#000000" stroke-width="2" marker-end="url(#arrow-black)" />
<line x1="670" y1="185" x2="695" y2="185" stroke="#000000" stroke-width="2" marker-end="url(#arrow-black)" />


<line x1="100" y1="185" x2="250" y2="185" stroke="#000000" stroke-width="2" marker-end="url(#arrow-black)" />
<text x="180" y="165" font-size="13" font-weight="bold" text-anchor="middle" transform="rotate(-15, 180, 165)">Zeiger auf</text>
<text x="180" y="180" font-size="13" font-weight="bold" text-anchor="middle" transform="rotate(-15, 180, 180)">Startknoten</text>


<path d="M 120 220 Q 250 340 435 230" fill="none" stroke="#000000" stroke-width="2" marker-end="url(#arrow-black)" />
<text x="280" y="315" font-size="14" font-weight="bold" fill="#222222">Zeiger auf</text>
<text x="280" y="335" font-size="14" font-weight="bold" fill="#222222">aktuellen Knoten</text>


<g transform="translate(230, 60) rotate(25)">
<polygon points="10,0 30,0 30,50 40,50 20,70 0,50 10,50" fill="#99cc99" stroke="#000000" stroke-width="1" />
<text x="20" y="40" font-size="13" transform="rotate(-90, 20, 40)" text-anchor="start" fill="#222222">Startknoten</text>
</g>


<g transform="translate(390, 60) rotate(25)">
<polygon points="10,0 30,0 30,50 40,50 20,70 0,50 10,50" fill="#99cc99" stroke="#000000" stroke-width="1" />
<text x="20" y="40" font-size="13" transform="rotate(-90, 20, 40)" text-anchor="start" fill="#222222">aktueller Knoten</text>
</g>
</svg>
</html>

== Aufbau und Spezifikation (API) ==
Im Kontext der objektorientierten Anwendungsentwicklung und in den landesweiten Vorgaben für das Zentralabitur wird die Liste über eine klar definierte Schnittstelle abstrahiert. Eine normgerechte Klasse <code>List</code> muss über die folgenden Methoden und Konstruktoren verfügen:

=== Konstruktor ===
* <code>List()</code>
** Eine leere Liste wird erzeugt.

=== Navigations- und Prüfmethoden ===
* <code>boolean isEmpty()</code>
** Die Anfrage liefert den Wert <code>true</code>, wenn die Liste keine Objekte enthält, sonst liefert sie den Wert <code>false</code>.
* <code>boolean hasAccess()</code>
** Die Anfrage liefert den Wert <code>true</code>, wenn es ein aktuelles Objekt gibt, sonst liefert sie <code>false</code>.
* <code>void next()</code>
** Falls die Liste nicht leer ist, es ein aktuelles Objekt gibt und dieses nicht das letzte Objekt der Liste ist, wird das dem aktuellen Objekt folgende Objekt zum neuen aktuellen Objekt. Andernfalls gibt es nach Ausführung des Auftrags kein aktuelles Objekt mehr (<code>hasAccess()</code> liefert den Wert <code>false</code>).
* <code>void toFirst()</code>
** Falls die Liste nicht leer ist, wird das erste Objekt der Liste zum aktuellen Objekt. Ist die Liste leer, geschieht nichts.
* <code>void toLast()</code>
** Falls die Liste nicht leer ist, wird das letzte Objekt der Liste zum aktuellen Objekt. Ist die Liste leer, geschieht nichts.

=== Methoden zur Datenmanipulation ===
* <code>Object getObject()</code>
** Falls es ein aktuelles Objekt gibt (<code>hasAccess() == true</code>), wird dieses zurückgegeben. Andernfalls gibt die Anfrage den Wert <code>null</code> zurück.
* <code>void setObject(Object pObject)</code>
** Falls es ein aktuelles Objekt gibt und <code>pObject</code> ungleich <code>null</code> ist, wird das aktuelle Objekt durch <code>pObject</code> ersetzt. Sonst bleibt die Liste unverändert.
* <code>void append(Object pObject)</code>
** Ein neues Objekt <code>pObject</code> wird am Ende der Liste eingefügt. Das aktuelle Objekt bleibt unverändert. Wenn die Liste leer ist, wird das Objekt in die Liste eingefügt und es gibt weiterhin kein aktuelles Objekt. Falls <code>pObject</code> gleich <code>null</code> ist, bleibt die Liste unverändert.
* <code>void insert(Object pObject)</code>
** Falls es ein aktuelles Objekt gibt, wird ein neues Objekt '''vor''' dem aktuellen Objekt in die Liste eingefügt. Das aktuelle Objekt bleibt unverändert. Falls die Liste leer ist, wird <code>pObject</code> in die Liste eingefügt und es gibt weiterhin kein aktuelles Objekt. Falls es kein aktuelles Objekt gibt und die Liste nicht leer ist, oder <code>pObject</code> gleich <code>null</code> ist, bleibt die Liste unverändert.
* <code>void concat(List pList)</code>
** Die Liste <code>pList</code> wird an die aufrufende Liste angehängt. Anschließend wird <code>pList</code> zu einer leeren Liste. Das aktuelle Objekt bleibt unverändert. Falls <code>pList</code> <code>null</code> oder bereits leer ist, bleibt die Liste unverändert.
* <code>void remove()</code>
** Falls es ein aktuelles Objekt gibt, wird dieses gelöscht und das Objekt '''hinter''' dem gelöschten Objekt wird zum neuen aktuellen Objekt. Wird das letzte Objekt der Liste gelöscht, gibt es danach kein aktuelles Objekt mehr. Wenn die Liste leer ist oder es kein aktuelles Objekt gibt, bleibt die Liste unverändert.

== Laufzeitanalyse (Komplexität) ==
Im Zuge der Softwareentwicklung ist die Auswahl der richtigen Datenstruktur hinsichtlich ihrer Effizienz kritisch[cite: 4]. Bei einer idealen, objektorientierten Implementierung einer Liste (mit Referenzen auf den ersten Knoten, den letzten Knoten und den aktuellen Knoten) ergeben sich gemäß der [[Landau-Symbole|Landau-Notation]] folgende Laufzeitkomplexitäten:

{| class="wikitable" style="text-align:center;"
|-
! Operation !! 1. Best-Case !! 2. Average-Case !! 3. Worst-Case
|-
| <code>append(Object pObject)</code> || <math>\mathcal{O}(1)</math> || <math>\mathcal{O}(1)</math> || <math>\mathcal{O}(1)</math>
|-
| <code>insert(Object pObject)</code> || <math>\mathcal{O}(1)</math> || <math>\mathcal{O}(n)</math> || <math>\mathcal{O}(n)</math>
|-
| <code>remove()</code> || <math>\mathcal{O}(1)</math> || <math>\mathcal{O}(n)</math> || <math>\mathcal{O}(n)</math>
|-
| Iteration (von vorne bis <code>n</code>) || <math>\mathcal{O}(1)</math> || <math>\mathcal{O}(n)</math> || <math>\mathcal{O}(n)</math>
|}

''Erläuterung:'' Da in einer einfach verketteten Liste nur vorwärts navigiert werden kann, erfordern <code>insert()</code> und <code>remove()</code> das Anpassen der Zeiger des Vorgängerknotens. Um den Vorgänger des aktuellen Knotens zu finden, muss die Liste im Average- und Worst-Case von vorne durchlaufen werden.

== Implementierungsbeispiel (Java) ==
Nachfolgend ist das prinzipielle Grundgerüst einer Listen-Implementierung auf Basis einer Knotenklasse (<code>ListNode</code>) dargestellt, wie es im Leistungskurs oder der Fachinformatik-Ausbildung entwickelt wird, um dynamische Datenstrukturen und das Kapselungsprinzip informationstechnisch zu fundieren[cite: 3].

<syntaxhighlight lang="java">
public class List {

// Innere Knoten-Klasse
private class ListNode {
Object content;
ListNode nextNode;

public ListNode(Object pContent) {
content = pContent;
nextNode = null;
}
}

// Zeiger auf wesentliche Elemente der Liste
private ListNode first;
private ListNode last;
private ListNode current;

/**
* Konstruktor
*/
public List() {
first = null;
last = null;
current = null;
}

public boolean isEmpty() {
return first == null;
}

public boolean hasAccess() {
return current != null;
}

public void next() {
if (this.hasAccess()) {
current = current.nextNode;
}
}

public void append(Object pObject) {
if (pObject != null) {
ListNode newNode = new ListNode(pObject);
if (this.isEmpty()) {
first = newNode;
last = newNode;
} else {
last.nextNode = newNode;
last = newNode;
}
}
}

public Object getObject() {
if (this.hasAccess()) {
return current.content;
}
return null;
}

// ... weitere Methoden (insert, remove, toFirst, etc.)
}
</syntaxhighlight>

[[Kategorie:Programmierung]]
[[Kategorie:AHR I Informatik LK]]
[[Kategorie:FI I SDM]]

Stapel

2026-09-04T07:41:28Z

Flbkwikiadmin:

== Einführung ==
In der Informatik bezeichnet ein '''Stapelspeicher''' oder '''Kellerspeicher''' (kurz ''Stapel'' oder ''Keller'', häufig auch mit dem englischen Fachbegriff '''Stack''' bezeichnet) eine fundamentale, dynamische Datenstruktur. Sie dient der temporären Zwischenspeicherung von Datenobjekten in einer streng definierten Reihenfolge und ist ein zentraler Bestandteil der objektorientierten Anwendungsentwicklung[cite: 3].

Objekte der abstrakten Datenstruktur (ADT) <code>Stack</code> verwalten beliebige Elemente nach dem '''LIFO-Prinzip''' (''Last-In-First-Out''). Das bedeutet: Das Element, welches als letztes auf den Stapel gelegt wurde, wird als erstes wieder entnommen.

'''Alltagsanalogie:'''
Ein Kellerspeicher lässt sich anschaulich mit einem Stapel von Umzugskisten oder einem Tellerstapel vergleichen. Es kann immer nur eine neue Kiste oben auf den Stapel gepackt werden (dies entspricht der Operation <code>push</code>). Ebenso kann immer nur die oberste Kiste heruntergenommen werden (entspricht der Operation <code>pop</code>). Der lesende oder schreibende Zugriff ist strukturell zwingend auf das oberste Element des Stapels beschränkt. Ein Hinzufügen oder Entfernen einer Kiste weiter unten im Stapel ist nicht möglich.

== Visualisierung ==
Die Arbeitsweise der LIFO-Datenstruktur lässt sich durch die beiden Hauptoperationen – das Hinzufügen (Push) und das Entfernen (Pop) – am Kopfende des Stapels veranschaulichen.

<html>
<svg width="500" height="360" viewBox="0 0 500 360" xmlns="http://www.w3.org/2000/svg" style="background-color: transparent;">

<defs>
<marker id="arrow-push" viewBox="0 0 10 10" refX="5" refY="5" markerWidth="6" markerHeight="6" orient="auto">
<path d="M 0 0 L 10 5 L 0 10 z" fill="#000000"/>
</marker>
<marker id="arrow-pop" viewBox="0 0 10 10" refX="5" refY="5" markerWidth="6" markerHeight="6" orient="auto">
<path d="M 0 0 L 10 5 L 0 10 z" fill="#000000"/>
</marker>
</defs>


<rect x="200" y="300" width="100" height="35" fill="#e0e0ff" stroke="#000000" stroke-width="1"/>
<rect x="200" y="260" width="100" height="35" fill="#c0c0ff" stroke="#000000" stroke-width="1"/>
<rect x="200" y="220" width="100" height="35" fill="#a0a0ff" stroke="#000000" stroke-width="1"/>
<rect x="200" y="180" width="100" height="35" fill="#8080ff" stroke="#000000" stroke-width="1"/>
<rect x="200" y="140" width="100" height="35" fill="#6060ff" stroke="#000000" stroke-width="1"/>
<rect x="200" y="100" width="100" height="35" fill="#4040ff" stroke="#000000" stroke-width="1"/>


<rect x="40" y="20" width="100" height="35" fill="#4040ff" stroke="#000000" stroke-width="1"/>
<text x="120" y="85" font-family="Arial, sans-serif" font-size="22" fill="#000000">Push</text>

<path d="M 140 60 Q 190 60 195 90" fill="none" stroke="#000000" stroke-width="2" marker-end="url(#arrow-push)"/>


<rect x="360" y="20" width="100" height="35" fill="#4040ff" stroke="#000000" stroke-width="1"/>
<text x="310" y="85" font-family="Arial, sans-serif" font-size="22" fill="#000000">Pop</text>

<path d="M 260 85 Q 270 50 350 40" fill="none" stroke="#000000" stroke-width="2" marker-end="url(#arrow-pop)"/>
</svg>
</html>

== Aufbau und Spezifikation (API) ==
Im Kontext der Softwaretechnologie wird diese abstrakte Datenstruktur formal über eine wohldefinierte Schnittstelle abgebildet, um die Kapselung der Daten zu gewährleisten[cite: 4]. Ein klassischer Stapel verfügt über die folgenden Methoden und Konstruktoren:

=== Konstruktor ===
* <code>Stack()</code>
** Ein neuer, leerer Stapel wird erzeugt.

=== Methoden ===
* <code>boolean isEmpty()</code>
** Die Anfrage liefert den Wert <code>true</code>, wenn der Stapel keine Objekte enthält. Andernfalls liefert sie den Wert <code>false</code>.
* <code>void push(Object pObject)</code>
** Das Objekt <code>pObject</code> wird oben auf den Stapel gelegt. Falls <code>pObject</code> den Wert <code>null</code> hat, bleibt der Stapel unverändert.
* <code>void pop()</code>
** Das zuletzt eingefügte (oberste) Objekt wird von dem Stapel entfernt. Falls der Stapel bereits leer ist, bleibt er unverändert (es tritt kein Fehler auf).
* <code>Object top()</code>
** Die Anfrage liefert das oberste Stapelobjekt zurück, ohne es aus der Datenstruktur zu entfernen. Der Stapel bleibt unverändert. Falls der Stapel leer ist, wird <code>null</code> zurückgegeben.

== Laufzeitanalyse (Komplexität) ==
Eine effiziente Implementierung des Stacks (beispielsweise über eine einfach verkettete Liste, bei der stets am Kopfknoten eingefügt und gelöscht wird) garantiert hochperformante Zugriffszeiten. Da ausschließlich auf das oberste Element zugegriffen wird, müssen keine iterativen Suchvorgänge durchgeführt oder nachfolgende Elemente im Speicher verschoben werden. Es ergibt sich gemäß der [[Landau-Symbole|Landau-Notation]] folgende Laufzeitkomplexität:

{| class="wikitable" style="text-align:center;"
|-
! Operation !! 1. Best-Case !! 2. Average-Case !! 3. Worst-Case
|-
| <code>push(Object pObject)</code> || <math>\mathcal{O}(1)</math> || <math>\mathcal{O}(1)</math> || <math>\mathcal{O}(1)</math>
|-
| <code>pop()</code> || <math>\mathcal{O}(1)</math> || <math>\mathcal{O}(1)</math> || <math>\mathcal{O}(1)</math>
|-
| <code>top()</code> || <math>\mathcal{O}(1)</math> || <math>\mathcal{O}(1)</math> || <math>\mathcal{O}(1)</math>
|-
| <code>isEmpty()</code> || <math>\mathcal{O}(1)</math> || <math>\mathcal{O}(1)</math> || <math>\mathcal{O}(1)</math>
|}

== Beispiel: Arbeitsweise der Stack-Operationen ==
Die Veränderung des inneren Zustands eines Stacks lässt sich anhand einer sequenziellen Abfolge von Operationen nachvollziehen. In der folgenden Tabelle ist das jeweils oberste Element (Top) der Liste rechts angeordnet.

{| class="wikitable"
|-
! Schritt !! Operation !! Zustand des Stacks (Bottom → Top) !! Erläuterung
|-
| 1. || <code>Stack()</code> || <code>[ ]</code> (leer) || Nach Aufruf des Konstruktors ist der Stack initialisiert, enthält aber noch keine Elemente.
|-
| 2. || <code>push(12)</code> || <code>[12]</code> || Nach Aufruf von <code>push(12)</code> enthält der Stack genau ein Element, nämlich die Zahl 12.
|-
| 3. || <code>push(8)</code> || <code>[12, 8]</code> || Nach Aufruf von <code>push(8)</code> sind zwei Elemente im Stack enthalten. Die 8 wurde zuletzt hinzugefügt, befindet sich also oben im Stack.
|-
| 4. || <code>pop()</code> || <code>[12]</code> || Wenn <code>pop()</code> aufgerufen wird, wird die 8 wieder entfernt – sie war die zuletzt hinzugefügte Zahl.
|-
| 5. || <code>push(15)</code> || <code>[12, 15]</code> || Nach <code>push(15)</code> besteht der Stack wieder aus zwei Elementen. Die 15 wurde zuletzt gepusht, liegt also oben auf dem Stack.
|-
| 6. || <code>push(16)</code> || <code>[12, 15, 16]</code> || Nach <code>push(16)</code> besteht der Stack aus drei Elementen. Wieder ist die zuletzt gepushte Zahl ganz oben im Stack. Ein Aufruf von <code>top()</code> würde nun <code>16</code> zurückgeben.
|}

== Implementierungsbeispiel (Java) ==
Für das tiefergehende Verständnis im Informatikunterricht ist nachfolgend eine klassische objektorientierte Implementierung des Stacks auf Basis einer einfach verketteten Liste (Knotenstruktur) dargestellt. Diese Implementierung ermöglicht das Anwenden dynamischer Datenstrukturen sowie die Untersuchung zur Effizienz und Korrektheit von Algorithmen[cite: 3].

<syntaxhighlight lang="java">
public class Stack {

// Verweis auf das oberste Element des Stapels
private Node head;

// Innere Knoten-Klasse zur Kapselung der Datenstruktur
private class Node {
Object content;
Node nextNode;

public Node(Object pContent) {
content = pContent;
nextNode = null;
}
}

/**
* Konstruktor: Ein leerer Stapel wird erzeugt.
*/
public Stack() {
head = null;
}

/**
* Prüft, ob der Stapel leer ist.
*/
public boolean isEmpty() {
return head == null;
}

/**
* Legt ein neues Objekt oben auf den Stapel.
*/
public void push(Object pObject) {
if (pObject != null) {
Node newNode = new Node(pObject);
newNode.nextNode = head; // Das neue Element zeigt auf den bisherigen Kopf
head = newNode; // Der Kopf wird auf das neue Element gesetzt
}
}

/**
* Entfernt das oberste Objekt vom Stapel.
*/
public void pop() {
if (!this.isEmpty()) {
head = head.nextNode; // Der Kopf rutscht ein Element nach unten (das alte Top-Element wird vom Garbage Collector entfernt)
}
}

/**
* Liefert das oberste Objekt des Stapels.
*/
public Object top() {
if (this.isEmpty()) {
return null;
} else {
return head.content;
}
}
}
</syntaxhighlight>

[[Kategorie:Programmierung]]
[[Kategorie:AHR I Informatik LK]]
[[Kategorie:FI I SDM]]

Keller

2026-09-04T07:40:54Z

Flbkwikiadmin: Weiterleitung nach Stapel erstellt

#redirect [[Stapel]]

Stapel

2026-09-04T07:39:25Z

Flbkwikiadmin: Die Seite wurde neu angelegt: „== Einführung == In der Informatik bezeichnet ein '''Stapelspeicher''' oder '''Kellerspeicher''' (kurz ''Stapel'' oder ''Keller'', häufig auch mit dem englischen Fachbegriff '''Stack''' bezeichnet) eine fundamentale, dynamische Datenstruktur[cite: 3]. Sie dient der Zwischenspeicherung von Datenobjekten in einer strikten Reihenfolge. Objekte der abstrakten Datenstruktur <code>Stack</code> verwalten beliebige Elemente nach dem '''LIFO-Prinzip''' (''Last-…“

== Einführung ==
In der Informatik bezeichnet ein '''Stapelspeicher''' oder '''Kellerspeicher''' (kurz ''Stapel'' oder ''Keller'', häufig auch mit dem englischen Fachbegriff '''Stack''' bezeichnet) eine fundamentale, dynamische Datenstruktur[cite: 3]. Sie dient der Zwischenspeicherung von Datenobjekten in einer strikten Reihenfolge.

Objekte der abstrakten Datenstruktur <code>Stack</code> verwalten beliebige Elemente nach dem '''LIFO-Prinzip''' (''Last-In-First-Out''). Das bedeutet: Das Element, welches als letztes auf den Stapel gelegt wurde, wird als erstes wieder entnommen.

[[Datei:image_90523e.png|mini|Veranschaulichung des LIFO-Prinzips mittels Push- und Pop-Operationen auf einem Stapel]]

'''Alltagsanalogie:'''
Ein Kellerspeicher lässt sich anschaulich mit einem Stapel von Umzugskisten vergleichen. Es kann immer nur eine neue Kiste oben auf den Stapel gepackt werden (dies entspricht der Operation <code>push</code>). Ebenso kann immer nur die oberste Kiste heruntergenommen werden (entspricht der Operation <code>pop</code>). Der lesende oder schreibende Zugriff ist im Regelfall streng auf das oberste Element des Stapels beschränkt. Ein Hinzufügen oder Entfernen einer Kiste weiter unten im Stapel ist strukturell nicht möglich.

== Aufbau und Spezifikation (API) ==
Im Kontext der objektorientierten Programmierung wird die abstrakte Datenstruktur formal über eine wohldefinierte Schnittstelle abgebildet[cite: 3]. Ein Stapel verfügt über die folgenden Methoden und Konstruktoren:

=== Konstruktor ===
* <code>Stack()</code>
** Ein neuer, leerer Stapel wird erzeugt.

=== Methoden ===
* <code>boolean isEmpty()</code>
** Die Anfrage liefert den Wert <code>true</code>, wenn der Stapel keine Objekte enthält. Andernfalls liefert sie den Wert <code>false</code>.
* <code>void push(Object pObject)</code>
** Das Objekt <code>pObject</code> wird oben auf den Stapel gelegt. Falls <code>pObject</code> den Wert <code>null</code> hat, bleibt der Stapel unverändert.
* <code>void pop()</code>
** Das zuletzt eingefügte (oberste) Objekt wird von dem Stapel entfernt. Falls der Stapel bereits leer ist, bleibt er unverändert.
* <code>Object top()</code>
** Die Anfrage liefert das oberste Stapelobjekt zurück, ohne es zu entfernen. Der Stapel bleibt unverändert. Falls der Stapel leer ist, wird <code>null</code> zurückgegeben.

== Laufzeitanalyse (Komplexität) ==
Eine effiziente Implementierung des Stacks (beispielsweise über eine einfach verkettete Liste, bei der stets vorne am Kopf eingefügt und gelöscht wird) garantiert hochperformante Zugriffszeiten. Dies ist für die informationstechnische Verarbeitung von Datenstrukturen in der beruflichen Praxis essenziell[cite: 4]. Da ausschließlich auf das oberste Element zugegriffen wird, müssen keine iterativen Suchvorgänge durchgeführt oder nachfolgende Elemente im Speicher verschoben werden. Es ergibt sich gemäß der [[Landau-Symbole|Landau-Notation]] folgende Laufzeitkomplexität:

{| class="wikitable"
|-
! Operation !! 1. Best-Case !! 2. Average-Case !! 3. Worst-Case
|-
| <code>push(Object pObject)</code> || <math>\mathcal{O}(1)</math> || <math>\mathcal{O}(1)</math> || <math>\mathcal{O}(1)</math>
|-
| <code>pop()</code> || <math>\mathcal{O}(1)</math> || <math>\mathcal{O}(1)</math> || <math>\mathcal{O}(1)</math>
|-
| <code>top()</code> || <math>\mathcal{O}(1)</math> || <math>\mathcal{O}(1)</math> || <math>\mathcal{O}(1)</math>
|-
| <code>isEmpty()</code> || <math>\mathcal{O}(1)</math> || <math>\mathcal{O}(1)</math> || <math>\mathcal{O}(1)</math>
|}

== Beispiel: Arbeitsweise der Stack-Operationen ==
Die Arbeitsweise und Veränderung des inneren Zustands eines Stacks lässt sich anhand einer sequenziellen Abfolge von Operationen veranschaulichen. In der folgenden Tabelle ist das jeweils oberste Element (Top) der Liste rechts angeordnet.

{| class="wikitable"
|-
! Schritt !! Operation !! Zustand des Stacks (Bottom -> Top) !! Erläuterung
|-
| 1. || <code>Stack()</code> || <code>[ ]</code> (leer) || Nach Aufruf der <code>Stack()</code>-Operation ist der Stack initialisiert, enthält aber noch keine Elemente.
|-
| 2. || <code>push(12)</code> || <code>[12]</code> || Nach Aufruf von <code>push(12)</code> enthält der Stack genau ein Element, nämlich die Zahl 12.
|-
| 3. || <code>push(8)</code> || <code>[12, 8]</code> || Nach Aufruf von <code>push(8)</code> sind zwei Elemente im Stack enthalten. Die 8 wurde zuletzt hinzugefügt, befindet sich also oben im Stack.
|-
| 4. || <code>pop()</code> || <code>[12]</code> || Wenn <code>pop()</code> aufgerufen wird, wird die 8 wieder entfernt – sie war die zuletzt hinzugefügte Zahl.
|-
| 5. || <code>push(15)</code> || <code>[12, 15]</code> || Nach <code>push(15)</code> besteht der Stack wieder aus zwei Elementen. Die 15 wurde zuletzt gepusht, also liegt sie oben auf dem Stack.
|-
| 6. || <code>push(16)</code> || <code>[12, 15, 16]</code> || Nach <code>push(16)</code> besteht der Stack aus drei Elementen. Wieder ist die zuletzt gepushte Zahl ganz oben im Stack.
|}

== Implementierungsbeispiel (Java) ==
Für das tiefergehende Verständnis im Leistungskurs oder der Fachinformatiker-Ausbildung ist nachfolgend eine klassische objektorientierte Implementierung des Stacks auf Basis einer einfach verketteten Liste (Knotenstruktur) dargestellt. Dies schult das exakte, strukturierte algorithmische Denken zur Lösung informationstechnischer Problemstellungen[cite: 3].

<syntaxhighlight lang="java">
public class Stack {

// Verweis auf das oberste Element des Stapels
private Node head;

// Innere Knoten-Klasse zur Kapselung der Daten
private class Node {
Object content;
Node nextNode;

public Node(Object pContent) {
content = pContent;
nextNode = null;
}
}

/**
* Konstruktor: Ein leerer Stapel wird erzeugt.
*/
public Stack() {
head = null;
}

/**
* Prüft, ob der Stapel leer ist.
*/
public boolean isEmpty() {
return head == null;
}

/**
* Legt ein neues Objekt oben auf den Stapel.
*/
public void push(Object pObject) {
if (pObject != null) {
Node newNode = new Node(pObject);
newNode.nextNode = head; // Das neue Element zeigt auf den bisherigen Kopf
head = newNode; // Der Kopf wird auf das neue Element gesetzt
}
}

/**
* Entfernt das oberste Objekt vom Stapel.
*/
public void pop() {
if (!this.isEmpty()) {
head = head.nextNode; // Der Kopf rutscht ein Element nach unten (das alte Top-Element wird vom Garbage Collector entfernt)
}
}

/**
* Liefert das oberste Objekt des Stapels.
*/
public Object top() {
if (this.isEmpty()) {
return null;
} else {
return head.content;
}
}
}
</syntaxhighlight>

[[Kategorie:Programmierung]]
[[Kategorie:AHR I Informatik LK]]
[[Kategorie:FI I SDM]]

Schlange

2026-09-04T07:26:10Z

Flbkwikiadmin:

== Einführung ==
In der Informatik bezeichnet eine '''Warteschlange''' oder '''Schlange''' (englisch ''Queue'') eine grundlegende und häufig eingesetzte dynamische Datenstruktur. Sie dient der geordneten Zwischenspeicherung von Datenobjekten, bevor diese systematisch weiterverarbeitet werden.

Warteschlangen verwalten beliebige Objekte nach dem strengen '''FIFO-Prinzip''' (''First-In-First-Out''). Das bedeutet: Das Element, welches zuerst in die Datenstruktur eingefügt wurde, wird auch als erstes wieder entnommen.

'''Alltagsanalogie:'''
Man kann sich diese Datenstruktur wie eine Warteschlange von Kunden an einer Supermarktkasse vorstellen. Der Letzte, der sich in die Schlange stellt, wird am Kopfende (''Back'') als Letzter bedient. Umgekehrt wird derjenige, der sich als Erstes an die Spitze (''Front'') angestellt hat, als Erster bedient.

== Funktionsweise und Visualisierung ==
Die grundlegenden Operationen einer Warteschlange verändern ihren Zustand, indem Elemente eingefügt oder entnommen werden. In der Abbildung unten ist die Funktionsweise schematisch dargestellt:

* Mit <code>enter</code> (bzw. <code>enqueue</code>) wird ein neuer Wert (im Beispiel die Zahl <code>3</code>) am Ende der Schlange (''Back'') hinzugefügt.
* Mit <code>leave</code> (bzw. <code>dequeue</code>) wird das am längsten gespeicherte Element (im Beispiel <code>37</code>) an der Spitze der Schlange (''Front'') herausgenommen.
* Der einzige lesende Zugriff erfolgt über die Operation <code>front</code>. Diese liefert das erste gespeicherte Element der Queue (hier <code>37</code>), unter der Annahme, dass die entnehmende Operation noch nicht ausgeführt wurde.

<html>
<svg width="600" height="200" viewBox="0 0 600 200" xmlns="http://www.w3.org/2000/svg" style="background-color: transparent;">

<g transform="translate(150, 80)">
<rect x="0" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" stroke-width="3"/>
<text x="20" y="25" text-anchor="middle" font-family="Arial" font-weight="bold" font-size="16">2</text>
<rect x="40" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" stroke-width="3"/>
<text x="60" y="25" text-anchor="middle" font-family="Arial" font-weight="bold" font-size="16">4</text>
<rect x="80" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" stroke-width="3"/>
<text x="100" y="25" text-anchor="middle" font-family="Arial" font-weight="bold" font-size="16">7</text>
<rect x="120" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" stroke-width="3"/>
<text x="140" y="25" text-anchor="middle" font-family="Arial" font-weight="bold" font-size="16">9</text>
<rect x="160" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" stroke-width="3"/>
<text x="180" y="25" text-anchor="middle" font-family="Arial" font-weight="bold" font-size="16">12</text>
<rect x="200" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" stroke-width="3"/>
<text x="220" y="25" text-anchor="middle" font-family="Arial" font-weight="bold" font-size="16">21</text>
<rect x="240" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" stroke-width="3"/>
<text x="260" y="25" text-anchor="middle" font-family="Arial" font-weight="bold" font-size="16">26</text>
<rect x="280" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" stroke-width="3"/>
<text x="300" y="25" text-anchor="middle" font-family="Arial" font-weight="bold" font-size="16">31</text>
<rect x="320" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" stroke-width="3"/>
<text x="340" y="25" text-anchor="middle" font-family="Arial" font-weight="bold" font-size="16">37</text>
</g>

<g transform="translate(40, 20)">
<rect x="0" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" stroke-width="3"/>
<text x="20" y="25" text-anchor="middle" font-family="Arial" font-weight="bold" font-size="16">3</text>
</g>
<path d="M 60 60 Q 60 100 130 100" fill="none" stroke="#8b0000" stroke-width="8" marker-end="url(#arrow-red)"/>
<text x="50" y="105" fill="#8b0000" font-family="Arial" font-size="14" font-weight="bold">enter</text>

<g transform="translate(520, 20)">
<rect x="0" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" stroke-width="3"/>
<text x="20" y="25" text-anchor="middle" font-family="Arial" font-weight="bold" font-size="16">37</text>
</g>
<path d="M 470 80 Q 470 40 505 40" fill="none" stroke="#8b0000" stroke-width="8" marker-end="url(#arrow-red)"/>
<text x="440" y="55" fill="#8b0000" font-family="Arial" font-size="14" font-weight="bold">leave</text>

<path d="M 490 180 L 490 135" fill="none" stroke="#006400" stroke-width="4" marker-end="url(#arrow-green)"/>
<text x="500" y="165" fill="#006400" font-family="Arial" font-size="14" font-weight="bold">front</text>
<defs>
<marker id="arrow-red" viewBox="0 0 10 10" refX="5" refY="5" markerWidth="6" markerHeight="6" orient="auto">
<path d="M 0 0 L 10 5 L 0 10 z" fill="#8b0000"/>
</marker>
<marker id="arrow-green" viewBox="0 0 10 10" refX="5" refY="5" markerWidth="6" markerHeight="6" orient="auto">
<path d="M 0 0 L 10 5 L 0 10 z" fill="#006400"/>
</marker>
</defs>
</svg>
</html>

Auch vertikal lässt sich das Konzept einer Queue anhand von Elementblöcken veranschaulichen. Hierbei rücken die Elemente wie auf einem Fließband weiter:

<html>
<svg width="500" height="200" viewBox="0 0 500 200" xmlns="http://www.w3.org/2000/svg" style="background-color: transparent;">

<g transform="translate(180, 80)">
<rect x="0" y="0" width="30" height="80" fill="#4d4dff" stroke="#000000" stroke-width="2"/>
<rect x="40" y="0" width="30" height="80" fill="#4d4dff" stroke="#000000" stroke-width="2"/>
<rect x="80" y="0" width="30" height="80" fill="#4d4dff" stroke="#000000" stroke-width="2"/>
<rect x="120" y="0" width="30" height="80" fill="#4d4dff" stroke="#000000" stroke-width="2"/>
<rect x="160" y="0" width="30" height="80" fill="#4d4dff" stroke="#000000" stroke-width="2"/>
<text x="15" y="-10" text-anchor="middle" font-family="Arial" font-size="16" font-weight="bold">Back</text>
<text x="175" y="-10" text-anchor="middle" font-family="Arial" font-size="16" font-weight="bold">Front</text>
</g>

<rect x="80" y="10" width="30" height="80" fill="#4d4dff" stroke="#000000" stroke-width="2"/>
<path d="M 95 90 Q 95 120 160 120" fill="none" stroke="#000000" stroke-width="2" marker-end="url(#arrow-black)"/>
<text x="150" y="145" text-anchor="end" font-family="Arial" font-size="18" font-weight="bold">Enqueue</text>

<path d="M 390 100 Q 430 100 445 130" fill="none" stroke="#000000" stroke-width="2" marker-end="url(#arrow-black)"/>
<text x="400" y="90" font-family="Arial" font-size="18" font-weight="bold">Dequeue</text>
<rect x="430" y="140" width="30" height="80" fill="#4d4dff" stroke="#000000" stroke-width="2"/>
<defs>
<marker id="arrow-black" viewBox="0 0 10 10" refX="5" refY="5" markerWidth="6" markerHeight="6" orient="auto">
<path d="M 0 0 L 10 5 L 0 10 z" fill="#000000"/>
</marker>
</defs>
</svg>
</html>

== Aufbau und Spezifikation (API) ==
Im Kontext der objektorientierten Programmierung wird die abstrakte Datenstruktur (ADT) formal über eine wohldefinierte Schnittstelle abgebildet. Eine <code>Queue</code> sollte über die folgenden Methoden und Konstruktoren verfügen:

=== Konstruktor ===
* <code>Queue()</code>
** Eine leere Schlange wird erzeugt. Der Zustand der initialisierten Schlange ist leer.

=== Methoden ===
* <code>boolean isEmpty()</code>
** Die Anfrage liefert den Wert <code>true</code>, wenn die Schlange keine Objekte enthält. Andernfalls liefert sie <code>false</code>.
* <code>void enqueue(Object pObject)</code>
** Das Objekt <code>pObject</code> wird an die Schlange (hinten) angehängt. Falls <code>pObject</code> gleich <code>null</code> ist, bleibt die Schlange unverändert.
* <code>void dequeue()</code>
** Das erste Objekt (vorne) wird aus der Schlange entfernt. Falls die Schlange bereits leer ist, wird sie nicht verändert.
* <code>Object front()</code>
** Die Anfrage liefert das erste Objekt der Schlange zurück, ohne dieses aus der Schlange zu entfernen (die Schlange bleibt unverändert). Falls die Schlange leer ist, wird <code>null</code> zurückgegeben.

== Laufzeitanalyse (Komplexität) ==
Warteschlangen lassen sich in der Praxis äußerst effizient über Arrays mit Ringpuffer-Logik oder über einfach verkettete Listen implementieren. Eine Zeigerstruktur, die stets den Anfang (Front) und das Ende (Tail) speichert, garantiert hochperformante Speicher- und Lesezugriffe. Für die oben genannten Methoden ergibt sich gemäß der [[O-Notation|O-Notation]] folgende Laufzeitkomplexität:

{| class="wikitable"
|-
! Operation !! 1. Best-Case !! 2. Average-Case !! 3. Worst-Case
|-
| <code>enqueue(Object pObject)</code> || <math>\mathcal{O}(1)</math> || <math>\mathcal{O}(1)</math> || <math>\mathcal{O}(1)</math>
|-
| <code>dequeue()</code> || <math>\mathcal{O}(1)</math> || <math>\mathcal{O}(1)</math> || <math>\mathcal{O}(1)</math>
|-
| <code>front()</code> || <math>\mathcal{O}(1)</math> || <math>\mathcal{O}(1)</math> || <math>\mathcal{O}(1)</math>
|-
| <code>isEmpty()</code> || <math>\mathcal{O}(1)</math> || <math>\mathcal{O}(1)</math> || <math>\mathcal{O}(1)</math>
|}

== Implementierungsbeispiel (Java) ==
Die grundlegende Struktur einer objektorientierten Implementierung als Rumpf-Klasse orientiert sich exakt an den curricularen Vorgaben.

<syntaxhighlight lang="java">
public class Queue {

// Verweise auf den Anfang und das Ende der Queue
private Node head;
private Node tail;

// Innere Knoten-Klasse für verkettete Listenstruktur
private class Node {
Object content;
Node nextNode;

public Node(Object pContent) {
content = pContent;
nextNode = null;
}
}

/**
* Konstruktor: Eine leere Schlange wird erzeugt.
*/
public Queue() {
head = null;
tail = null;
}

/**
* Prüft, ob die Schlange leer ist.
*/
public boolean isEmpty() {
return head == null;
}

/**
* Fügt ein Objekt hinten an die Schlange an.
*/
public void enqueue(Object pObject) {
if (pObject != null) {
Node newNode = new Node(pObject);
if (this.isEmpty()) {
head = newNode;
tail = newNode;
} else {
tail.nextNode = newNode;
tail = newNode;
}
}
}

/**
* Entfernt das vorderste Element aus der Schlange.
*/
public void dequeue() {
if (!this.isEmpty()) {
head = head.nextNode;
if (this.isEmpty()) {
tail = null;
}
}
}

/**
* Gibt das vorderste Element zurück.
*/
public Object front() {
if (this.isEmpty()) {
return null;
} else {
return head.content;
}
}
}
</syntaxhighlight>

[[Kategorie:Programmierung]]
[[Kategorie:AHR_I_Informatik LK]]
[[Kategorie:FI I SDM]]

Schlange

2026-09-04T07:25:32Z

Flbkwikiadmin: Die Seite wurde neu angelegt: „== Einführung == In der Informatik bezeichnet eine '''Warteschlange''' oder '''Schlange''' (englisch ''Queue'') eine grundlegende und häufig eingesetzte dynamische Datenstruktur. Sie dient der geordneten Zwischenspeicherung von Datenobjekten, bevor diese systematisch weiterverarbeitet werden. Warteschlangen verwalten beliebige Objekte nach dem strengen '''FIFO-Prinzip''' (''First-In-First-Out''). Das bedeutet: Das Element, welches zuerst in die Datens…“

== Einführung ==
In der Informatik bezeichnet eine '''Warteschlange''' oder '''Schlange''' (englisch ''Queue'') eine grundlegende und häufig eingesetzte dynamische Datenstruktur. Sie dient der geordneten Zwischenspeicherung von Datenobjekten, bevor diese systematisch weiterverarbeitet werden.

Warteschlangen verwalten beliebige Objekte nach dem strengen '''FIFO-Prinzip''' (''First-In-First-Out''). Das bedeutet: Das Element, welches zuerst in die Datenstruktur eingefügt wurde, wird auch als erstes wieder entnommen.

'''Alltagsanalogie:'''
Man kann sich diese Datenstruktur wie eine Warteschlange von Kunden an einer Supermarktkasse vorstellen. Der Letzte, der sich in die Schlange stellt, wird am Kopfende (''Back'') als Letzter bedient. Umgekehrt wird derjenige, der sich als Erstes an die Spitze (''Front'') angestellt hat, als Erster bedient.

== Funktionsweise und Visualisierung ==
Die grundlegenden Operationen einer Warteschlange verändern ihren Zustand, indem Elemente eingefügt oder entnommen werden. In der Abbildung unten ist die Funktionsweise schematisch dargestellt:

* Mit <code>enter</code> (bzw. <code>enqueue</code>) wird ein neuer Wert (im Beispiel die Zahl <code>3</code>) am Ende der Schlange (''Back'') hinzugefügt.
* Mit <code>leave</code> (bzw. <code>dequeue</code>) wird das am längsten gespeicherte Element (im Beispiel <code>37</code>) an der Spitze der Schlange (''Front'') herausgenommen.
* Der einzige lesende Zugriff erfolgt über die Operation <code>front</code>. Diese liefert das erste gespeicherte Element der Queue (hier <code>37</code>), unter der Annahme, dass die entnehmende Operation noch nicht ausgeführt wurde.

<html>
<svg width="600" height="200" viewBox="0 0 600 200" xmlns="http://www.w3.org/2000/svg" style="background-color: transparent;">

<g transform="translate(150, 80)">
<rect x="0" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" stroke-width="3"/>
<text x="20" y="25" text-anchor="middle" font-family="Arial" font-weight="bold" font-size="16">2</text>
<rect x="40" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" stroke-width="3"/>
<text x="60" y="25" text-anchor="middle" font-family="Arial" font-weight="bold" font-size="16">4</text>
<rect x="80" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" stroke-width="3"/>
<text x="100" y="25" text-anchor="middle" font-family="Arial" font-weight="bold" font-size="16">7</text>
<rect x="120" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" stroke-width="3"/>
<text x="140" y="25" text-anchor="middle" font-family="Arial" font-weight="bold" font-size="16">9</text>
<rect x="160" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" stroke-width="3"/>
<text x="180" y="25" text-anchor="middle" font-family="Arial" font-weight="bold" font-size="16">12</text>
<rect x="200" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" stroke-width="3"/>
<text x="220" y="25" text-anchor="middle" font-family="Arial" font-weight="bold" font-size="16">21</text>
<rect x="240" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" stroke-width="3"/>
<text x="260" y="25" text-anchor="middle" font-family="Arial" font-weight="bold" font-size="16">26</text>
<rect x="280" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" stroke-width="3"/>
<text x="300" y="25" text-anchor="middle" font-family="Arial" font-weight="bold" font-size="16">31</text>
<rect x="320" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" stroke-width="3"/>
<text x="340" y="25" text-anchor="middle" font-family="Arial" font-weight="bold" font-size="16">37</text>
</g>

<g transform="translate(40, 20)">
<rect x="0" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" stroke-width="3"/>
<text x="20" y="25" text-anchor="middle" font-family="Arial" font-weight="bold" font-size="16">3</text>
</g>
<path d="M 60 60 Q 60 100 130 100" fill="none" stroke="#8b0000" stroke-width="8" marker-end="url(#arrow-red)"/>
<text x="50" y="105" fill="#8b0000" font-family="Arial" font-size="14" font-weight="bold">enter</text>

<g transform="translate(520, 20)">
<rect x="0" y="0" width="40" height="40" fill="#ffffff" stroke="#000000" stroke-width="3"/>
<text x="20" y="25" text-anchor="middle" font-family="Arial" font-weight="bold" font-size="16">37</text>
</g>
<path d="M 470 80 Q 470 40 505 40" fill="none" stroke="#8b0000" stroke-width="8" marker-end="url(#arrow-red)"/>
<text x="440" y="55" fill="#8b0000" font-family="Arial" font-size="14" font-weight="bold">leave</text>

<path d="M 490 180 L 490 135" fill="none" stroke="#006400" stroke-width="4" marker-end="url(#arrow-green)"/>
<text x="500" y="165" fill="#006400" font-family="Arial" font-size="14" font-weight="bold">front</text>
<defs>
<marker id="arrow-red" viewBox="0 0 10 10" refX="5" refY="5" markerWidth="6" markerHeight="6" orient="auto">
<path d="M 0 0 L 10 5 L 0 10 z" fill="#8b0000"/>
</marker>
<marker id="arrow-green" viewBox="0 0 10 10" refX="5" refY="5" markerWidth="6" markerHeight="6" orient="auto">
<path d="M 0 0 L 10 5 L 0 10 z" fill="#006400"/>
</marker>
</defs>
</svg>
</html>

Auch vertikal lässt sich das Konzept einer Queue anhand von Elementblöcken veranschaulichen. Hierbei rücken die Elemente wie auf einem Fließband weiter:

<html>
<svg width="500" height="200" viewBox="0 0 500 200" xmlns="http://www.w3.org/2000/svg" style="background-color: transparent;">

<g transform="translate(180, 80)">
<rect x="0" y="0" width="30" height="80" fill="#4d4dff" stroke="#000000" stroke-width="2"/>
<rect x="40" y="0" width="30" height="80" fill="#4d4dff" stroke="#000000" stroke-width="2"/>
<rect x="80" y="0" width="30" height="80" fill="#4d4dff" stroke="#000000" stroke-width="2"/>
<rect x="120" y="0" width="30" height="80" fill="#4d4dff" stroke="#000000" stroke-width="2"/>
<rect x="160" y="0" width="30" height="80" fill="#4d4dff" stroke="#000000" stroke-width="2"/>
<text x="15" y="-10" text-anchor="middle" font-family="Arial" font-size="16" font-weight="bold">Back</text>
<text x="175" y="-10" text-anchor="middle" font-family="Arial" font-size="16" font-weight="bold">Front</text>
</g>

<rect x="80" y="10" width="30" height="80" fill="#4d4dff" stroke="#000000" stroke-width="2"/>
<path d="M 95 90 Q 95 120 160 120" fill="none" stroke="#000000" stroke-width="2" marker-end="url(#arrow-black)"/>
<text x="150" y="145" text-anchor="end" font-family="Arial" font-size="18" font-weight="bold">Enqueue</text>

<path d="M 390 100 Q 430 100 445 130" fill="none" stroke="#000000" stroke-width="2" marker-end="url(#arrow-black)"/>
<text x="400" y="90" font-family="Arial" font-size="18" font-weight="bold">Dequeue</text>
<rect x="430" y="140" width="30" height="80" fill="#4d4dff" stroke="#000000" stroke-width="2"/>
<defs>
<marker id="arrow-black" viewBox="0 0 10 10" refX="5" refY="5" markerWidth="6" markerHeight="6" orient="auto">
<path d="M 0 0 L 10 5 L 0 10 z" fill="#000000"/>
</marker>
</defs>
</svg>
</html>

== Aufbau und Spezifikation (API) ==
Im Kontext der objektorientierten Programmierung wird die abstrakte Datenstruktur (ADT) formal über eine wohldefinierte Schnittstelle abgebildet. Eine <code>Queue</code> sollte über die folgenden Methoden und Konstruktoren verfügen:

=== Konstruktor ===
* <code>Queue()</code>
** Eine leere Schlange wird erzeugt. Der Zustand der initialisierten Schlange ist leer.

=== Methoden ===
* <code>boolean isEmpty()</code>
** Die Anfrage liefert den Wert <code>true</code>, wenn die Schlange keine Objekte enthält. Andernfalls liefert sie <code>false</code>.
* <code>void enqueue(Object pObject)</code>
** Das Objekt <code>pObject</code> wird an die Schlange (hinten) angehängt. Falls <code>pObject</code> gleich <code>null</code> ist, bleibt die Schlange unverändert.
* <code>void dequeue()</code>
** Das erste Objekt (vorne) wird aus der Schlange entfernt. Falls die Schlange bereits leer ist, wird sie nicht verändert.
* <code>Object front()</code>
** Die Anfrage liefert das erste Objekt der Schlange zurück, ohne dieses aus der Schlange zu entfernen (die Schlange bleibt unverändert). Falls die Schlange leer ist, wird <code>null</code> zurückgegeben.

== Laufzeitanalyse (Komplexität) ==
Warteschlangen lassen sich in der Praxis äußerst effizient über Arrays mit Ringpuffer-Logik oder über einfach verkettete Listen implementieren. Eine Zeigerstruktur, die stets den Anfang (Front) und das Ende (Tail) speichert, garantiert hochperformante Speicher- und Lesezugriffe. Für die oben genannten Methoden ergibt sich gemäß der [[Landau-Symbole|Landau-Notation]] folgende Laufzeitkomplexität:

{| class="wikitable"
|-
! Operation !! 1. Best-Case !! 2. Average-Case !! 3. Worst-Case
|-
| <code>enqueue(Object pObject)</code> || <math>\mathcal{O}(1)</math> || <math>\mathcal{O}(1)</math> || <math>\mathcal{O}(1)</math>
|-
| <code>dequeue()</code> || <math>\mathcal{O}(1)</math> || <math>\mathcal{O}(1)</math> || <math>\mathcal{O}(1)</math>
|-
| <code>front()</code> || <math>\mathcal{O}(1)</math> || <math>\mathcal{O}(1)</math> || <math>\mathcal{O}(1)</math>
|-
| <code>isEmpty()</code> || <math>\mathcal{O}(1)</math> || <math>\mathcal{O}(1)</math> || <math>\mathcal{O}(1)</math>
|}

== Implementierungsbeispiel (Java) ==
Die grundlegende Struktur einer objektorientierten Implementierung als Rumpf-Klasse orientiert sich exakt an den curricularen Vorgaben.

<syntaxhighlight lang="java">
public class Queue {

// Verweise auf den Anfang und das Ende der Queue
private Node head;
private Node tail;

// Innere Knoten-Klasse für verkettete Listenstruktur
private class Node {
Object content;
Node nextNode;

public Node(Object pContent) {
content = pContent;
nextNode = null;
}
}

/**
* Konstruktor: Eine leere Schlange wird erzeugt.
*/
public Queue() {
head = null;
tail = null;
}

/**
* Prüft, ob die Schlange leer ist.
*/
public boolean isEmpty() {
return head == null;
}

/**
* Fügt ein Objekt hinten an die Schlange an.
*/
public void enqueue(Object pObject) {
if (pObject != null) {
Node newNode = new Node(pObject);
if (this.isEmpty()) {
head = newNode;
tail = newNode;
} else {
tail.nextNode = newNode;
tail = newNode;
}
}
}

/**
* Entfernt das vorderste Element aus der Schlange.
*/
public void dequeue() {
if (!this.isEmpty()) {
head = head.nextNode;
if (this.isEmpty()) {
tail = null;
}
}
}

/**
* Gibt das vorderste Element zurück.
*/
public Object front() {
if (this.isEmpty()) {
return null;
} else {
return head.content;
}
}
}
</syntaxhighlight>

[[Kategorie:Programmierung]]
[[Kategorie:AHR_I_Informatik LK]]
[[Kategorie:FI I SDM]]

Dynamische Datenstruktur

2026-09-04T07:24:05Z

Flbkwikiadmin:

'''Dynamische Datenstrukturen''' sind in der Programmierung Behälter für [[Objekt|Objekte]], die eine flexible Menge an Arbeitsspeicher reservieren und somit eine beliebige Anzahl von Objekten aufnehmen können. Im Gegensatz zu [[Array|Arrays]] mit fester Länge bieten sie mehr Flexibilität bei der Verwaltung von Datenmengen.

== Einführung ==
In einem Programm werden oft mehrere Objekte einer Klasse verwaltet. Diese müssen in Behältern organisiert werden. Ein Beispiel für einen solchen Behälter ist das [[Array]]. Da ein Array immer eine feste Länge hat, ist es für viele Zwecke allerdings zu unflexibel. Beispiele für dynamische Datenstrukturen sind:

[[Schlange|Schlange (Queue)]]

[[Stapel|Stapel (Stack)]]

[[Liste|Liste (List)]]

Der reservierte Arbeitsspeicher ist abhängig vom [[Datentyp]] der gespeicherten Objekte. Dynamische Datenstrukturen bieten Mechanismen, den reservierten Speicher mit jeder hinzugefügten Dateneinheit zu vergrößern. In manchen Situationen ist es erforderlich, eigene Strukturen zu entwerfen, die Objekte dynamisch verwalten.

== Knoten ==
Dynamische Datenstrukturen lassen sich mit Arrays oder Knoten realisieren. Ein '''Knoten''' ist ein Objekt einer Klasse. Die Klasse definiert, wie ihre Instanzen mit Hilfe von [[Zeiger|Zeigern]] zu verketten sind, so dass eine Listenstruktur entsteht. Eine Knoteninstanz kann mehrere Zeiger besitzen. Zeiger können auf nichts (Wert <code>null</code>), auf einen anderen oder auf den eigenen Knoten zeigen. Mindestens ein Zeiger muss "von außen" auf die Struktur verweisen (im Bild der Zeiger <code>start</code>). Welche Daten in einem Knoten verwaltet werden, wird in der zugehörigen Klasse durch [[Instanzvariable]]n definiert. Die Knoten können unidirektional oder bidirektional angelegt werden.

=== Unidirektional ===
[[Datei:Unidirektionaler Knoten.png|mini]]
Unidirektional (lateinisch ''uni'' für „ein“) bedeutet, dass mit Hilfe eines Zeigers nur in eine Richtung verwiesen wird. So kann zum Beispiel ein unidirektionaler Knoten nur auf seinen Nachfolger, nicht aber auf seinen Vorgänger verweisen.

=== Bidirektional ===
[[Datei:Bidirektionaler Knoten.png|mini]]
Ein bidirektionaler (nach der lateinischen Vorsilbe ''bi-'' für „zwei“) Knoten kann in zwei Richtungen verweisen. So kann zum Beispiel ein bidirektionaler Knoten nicht nur auf seinen Nachfolger, sondern auch zusätzlich auf seinen Vorgänger verweisen.

== Beispiel ==
[[Datei:BlueJ Inspektion.png|mini]]
<math>
meineListe \rightarrow \boxed{5}\boxed{\phantom{5}}
\rightarrow \boxed{42}\boxed{\phantom{42}}
\rightarrow \boxed{16}\boxed{\phantom{16}}
</math>
<syntaxhighlight lang="java">
public class Knoten {
private double daten; // Attribut mit Daten zum Beispiel 5 oder 42
private Knoten naechster; // Zeiger auf den nächsten Knoten

// einfacher Konstruktor
public Knoten() {
naechster = null; // zeigt noch nirgendwo hin
}

// einfacher Konstruktor
public Knoten(double n) {
daten = n;
naechster = null; // zeigt noch nirgendwo hin
}

// Konstruktor mit Ziel
public Knoten(double n, Knoten next) {
daten = n;
naechster = next; // zeigt auf den nächsten Knoten
}

// Getter und Setter
public Knoten getNaechster() {
return naechster;
}

public void setNaechster(Knoten naechster) {
this.naechster = naechster;
}
}
</syntaxhighlight>

<syntaxhighlight lang="java"> public class Liste { private Knoten start;
text
public void testen() {
start = new Knoten();
Knoten knoten1 = new Knoten(5.0);
Knoten knoten2 = new Knoten(16.0);
Knoten knoten3 = new Knoten(42.0);

start.setNaechster(knoten1);
knoten1.setNaechster(knoten2);
knoten2.setNaechster(knoten3);
}

public Knoten getStart() {
return start;
}
}
</syntaxhighlight>
== Collection Framework ==
[[Java]] fasst die bereitgestellten Datenbehälter im Java Collection Framework zusammen. Neben den eigentlichen Containern gehören auch noch Standardmethoden wie beispielsweise das [[Sortierverfahren|Sortieren]] dazu, die auf den Containern arbeiten. Die Grundlage dieses Frameworks sind so genannte Interfaces, die das typische Verhalten der Datencontainer vorgeben.

Die Klasse <code>java.util.ArrayList</code> ist z.B. eine dynamische Datenstruktur, die das <code>List</code>-Interface - ein Subinterface von <code>Collection</code> - implementiert hat. In der Listenstruktur der <code>ArrayList</code> können beliebig viele Objekte hinzugefügt und dann auch wieder entfernt werden.

[[Kategorie:Programmierung]]
[[Kategorie:FI_I_SDM]]
[[Kategorie:FI_I_TP1]]
[[Kategorie:AHR_I_Informatik_LK]]

Hauptsatz der Differential- und Integralrechnung

2026-07-11T08:07:23Z

Flbkwikiadmin: /* Definition */

Mit Hilfe des Hauptsatzes der Differential- und Integralrechnung werden Flächeninhalte zwischen dem [[Graph|Graphen]] einer [[Funktion]] der x-Achse berechnet.

==Flächeninhaltsfunktion und Stammfunktion==
Der Flächeninhalt zwischen dem Graphen einer Funktion <math>f</math> und der x-Achse im Intervall <math>[0;x]</math> wird durch den Funktionswert einer '''Flächeninhaltsfunktion''' <math>A</math> ermittelt.

Es sei <math>F</math> die [[Stammfunktion]] zu einer [[ganzrationale_Funktion|ganzrationalen Funktion]] <math>f</math> mit der Konstanten <math>C=0</math>, dann ist <math>F</math> die Flächeninhaltsfunktion zu <math>f</math>.

<html><iframe width="280" height="157.5" src="https://www.youtube.com/embed/r-iUbclLabI?si=a5pPkIEuYHEhuoWi" 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></html>

==Bestimmtes Integral==
Das '''bestimmte Integral''' einer [[Stetige_Funktion|stetigen Funktion]] <math>f</math> auf dem Intervall <math>[a; b]</math> ist durch
:<math>\int_a^b f(x) \, dx</math>
gegeben.

Für auf den Intervallen <math>[a;b] \subseteq [a;c]</math> und <math>[b;c] \subseteq [a;c]</math> stetige Funktionen <math>f, ~g</math> gelten die folgenden Rechenregeln:
===Faktorregel===
:<math>\int_a^b c \cdot f(x) \, dx=c \cdot \int_a^b f(x) \, dx</math>
===Summenregel===
:<math>\int_a^b (f(x)+g(x)) \, dx = \int_a^b f(x) \, dx + \int_a^bg(x) \, dx</math>
===Intervalladditivität===
:<math>\int_a^c f(x) \, dx=\int_a^b f(x) \, dx+\int_b^c f(x) \, dx</math>

===Vertauschen der Integrationsgrenzen===
:<math>\int_a^b f(x) \, dx=-\int_b^a f(x) \, dx</math>

==Definition==
Falls <math>F</math> eine [[Stammfunktion]] von <math>f</math> ist, so wird das bestimmte Integral von <math>f</math> auf dem Intervall <math>[a;b]</math> durch die Gleichung
:<math>\int_a^b f(x) \, dx = F(b) - F(a)</math>
berechnet.

Hierbei bezeichnet <math>a</math> die untere und <math>b</math> die obere Grenze des Integrals. Das bestimmte Integral gibt den '''orientierten Flächeninhalt''' an, das heißt:
* Liegt der Graph von <math>f</math> oberhalb der x-Achse, ist das bestimmte Integral positiv.
* Liegt der Graph von <math>f</math> unterhalb der x-Achse, ist das bestimmte Integral negativ.
* Liegt der Graph von <math>f</math> sowohl unterhalb als auch oberhalb der x-Achse, ist das bestimmte Integral die Differenz aus dem oberen Flächeninhalt und dem unteren Flächeninhalt.

<html>
<head>
<link rel="stylesheet" href="/localassets/jsxgraph/jsxgraph.css">
<script src="/localassets/jsxgraph/jsxgraphcore.js"></script>

</head>
<body>
<div id="box2" style="width: 90vw; max-width: 400px; height: 60vw; max-height: 300px; margin-top:20px;"></div>
<script type="text/javascript">
JXG.Options.text.useMathJax = true;
// JSXGraph-Board erstellen
var board = JXG.JSXGraph.initBoard('box2', {
boundingbox: [-5, 5, 10, -5], // Angepasste Boundingbox für die Skalierung
axis: true,
showCopyright: false,
showNavigation: true,
grid: true, // Gitternetz aktivieren
defaultAxes: {
x: {
withLabel: true,
name: '\\[t\\]',
label: {
position: 'rt',
offset: [-5, 20],
fontSize: 14,
anchorX: 'right'
},
ticks: {
ticksDistance: 1,
minorTicks: 0
}
},
y: {
withLabel: true,
name: '\\[f(t)\\]',
label: {
position: 'rt',
offset: [5, 20],
fontSize: 14,
anchorY: 'right'
},
ticks: {
ticksDistance: 1,
minorTicks: 0
}
}
}
});

// Funktion erstellen
var c1 = board.create('functiongraph', [function(t) {
return (Math.pow(t, 5) / 24 - Math.pow(t, 3) / 2 + t);
}]);

// Integral erstellen
var i1 = board.create('integral', [
[-2.0, 2.0], c1
], {
withLabel: true,
label: {
fontSize: 14,
offset: [0, 50],
digits: 4,
intl: {
enabled: false,
options: {}
}
},
baseLeft: { // Start point
visible: true,
fixed: false,
withLabel: true,
name: 'a'
},
baseRight: { // End point
visible: true,
fixed: false,
withLabel: true,
name: 'b'
}
});

// Integral-Label anpassen
i1.label.setText(() => {
const a = i1.baseLeft.X().toFixed(2); // Untere Grenze
const b = i1.baseRight.X().toFixed(2); // Obere Grenze
const value = i1.Value().toFixed(4); // Wert des Integrals
return `\\[\\int_{${a}}^{${b}} f(t) \\, dt = ${value}\\]`;
});

// Beschriftung der Funktion mit f
board.create('text', [3.5, 3, '\\[f\\]'], {
fontSize: 14,
fixed: true,
anchorX: 'left',
anchorY: 'bottom',
color: 'blue'
});
</script>
</body>
</html>

<html><iframe width="280" height="157.5" src="https://www.youtube.com/embed/Lc_R0vBSKHw?si=V72WfOUjhQRQlrN9" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe></html>

<html><iframe width="280" height="157,5" src="https://www.youtube.com/embed/MX_WQS5-vAg?si=N2TxoCi_PHsr1_1B" 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></html>

==Integralfunktion==
Es sei <math>f</math> eine auf dem Intervall <math>[a;b]</math> [[stetige Funktion]], dann ist
:<math>I_a(x)=\int_a^x f(t) \, dt</math>
die dazugehörige '''Integralfunktion'''.

==Flächen zwischen Funktionsgraphen ermitteln==
Es seien <math>f, ~g</math> auf dem Intervall <math>[a;b]</math> stetige Funktionen. Die Fläche zwischen den Graphen von <math>f, ~g</math> wird wie folgt ermittelt:
# Schnittstellen <math>x_{S_1},\dots,x_{S_n}</math> mit <math>n \in \mathbb{N}</math> der Graphen von <math>f, ~g</math> ermitteln.
# Stammfunktionen <math>F,~G</math> ermitteln
# <math>A=|\int_{x_{S_1}}^{x_{S_2}}(f(x)-g(x)) \, dx|+|\int_{x_{S_2}}^{x_{S_3}}(f(x)-g(x)) \, dx|+\dots+|\int_{x_{S_{n-1}}}^{x_{S_n}}(f(x)-g(x)) \, dx|</math> berechnen. (siehe [[Betragsfunktion]])

==Beispiele==

===Flächeninhalt ermitteln===
[[Datei:HauptsatzIntBspx2.gif|mini|Das bestimmte Integral der Funktion <span style="color:blue"><math>f(x)=x^2</math></span> auf dem Intervall <math>[1;2] </math> berechnet sich durch <span style="color:green"><math>\int_1^2 x^2 \, dx=\frac{7}{3}</math></span>.]]

Wir berechnen das bestimmte Integral von <math>f(x) = x^2</math> auf dem Intervall <math>[1;2]</math>.
Eine Stammfunktion von <math>f</math> ist <math>F(x) = \frac{x^3}{3}</math>.
Das bestimmte Integral auf dem Intervall [1;2] wird durch
:<math>\int_1^2 x^2 \, dx = F(2) - F(1)</math>
:<math>= \frac{2^3}{3} - \frac{1^3}{3} = \frac{8}{3} - \frac{1}{3} = \frac{7}{3}</math>
berechnet.
Der Graph von <math>f</math> verläuft auf dem Intervall <math>[1;2]</math> oberhalb der x-Achse. Der Flächeninhalt beträgt somit <math>\frac{7}{3}</math> Einheiten und ist im rechten Bild grün eingezeichnet.

Wir berechnen den Flächeninhalt zwischen dem Graphen von $f(t)=\frac{t^5}{24}-\frac{t^3}{2}+t$ und der x-Achse auf dem Intervall <math>[-2;2]</math> (siehe [[Hauptsatz_der_Differential-_und_Integralrechnung#Definition|Graph von <math>f</math>]]).

1. Nullstellen von <math>f</math> berechnen
:<math>\frac{t^5}{24}-\frac{t^3}{2}+t=0</math>
:<math>t \approx -3,08 \lor t \approx -1,59 \lor t \approx 0 \lor t \approx 1,59 \lor t \approx 3,08</math>
:<math>-1,59; 0; 1,59 \in [-2;2]</math>
2. Flächeninhalt ermitteln
:<math>A=|\int_{-2}^{-1,59} f(t) \, dt|+|\int_{-1,59}^{0} f(t) \, dt|+|\int_{0}^{1,59} f(t) \, dt|+|\int_{1,59}^{2} f(t) \, dt| </math>
:<math>\approx |0,13|+|-0,58|+|0,58|+|-0,13| = 0,13+0,58+0,58+0,13= 1,42</math>
Der gesuchte Flächeninhalt beträgt <math>A=1,42</math>. Der orientierte Flächeninhalt auf dem Intervall <math>[-2;2]</math> beträgt <math>\int_{-2}^{2} f(t) \, dt=0</math>.

===Orientierten Flächeninhalt ermitteln===
[[Datei:HauptsatzIntBspx.gif|mini|Das bestimmte Integral der Funktion <span style="color:blue"><math>f(x)=x</math></span> auf dem Intervall <math>[-1;1] </math> berechnet sich durch <math>\int_{-1}^1 x \, dx=</math><span style="color:green"><math>\frac{1}{2}</math></span><span style="color:red"><math>-</math><math>\frac{1}{2}</math></span><math>=0</math>.]]

Wir betrachten <math>f(x) = x</math> auf dem Intervall <math>[-1;1]</math>.
Eine Stammfunktion von <math>f</math> ist <math>F(x) = \frac{x^2}{2}</math>.
Das bestimmte Integral ist:
:<math>\int_{-1}^1 x \, dx = F(1) - F(-1)</math>
:<math>= \frac{1^2}{2} - \frac{(-1)^2}{2} = \frac{1}{2} - \frac{1}{2} = 0</math>.
Der orientierte Flächeninhalt beträgt <math>0</math>, da sich die positiven und negativen Flächeninhalte genau ausgleichen.

===Integralfunktion ermitteln===
Gegeben sei <math>f(x) = 3x</math> und <math>a = 0</math>.
Die Integralfunktion ist:
:<math>I_0(x) = \int_0^x 3t \, dt</math>.
Eine Stammfunktion von <math>3t</math> ist <math>\frac{3t^2}{2}</math>, also gilt
:<math>I_0(x) = \frac{3x^2}{2} - \frac{3 \cdot 0^2}{2} = \frac{3x^2}{2}</math>.

===Flächeninhalt zwischen den Graphen von zwei Funktionen ermitteln===
[[Datei:HauptsatzIntFlächenZwGraphen.gif|mini|Fläche zwischen den Graphen von zwei Funktionen ermitteln]]

Wir betrachten die Funktionen <math>f(x)=x^2+1</math> und <math>g(x)=-x^2+3</math> und ermitteln die Fläche zwischen den Graphen der Funktionen.

1. Schnittstellen von <math>g,~f</math> ermitteln <br>
:<math>f(x)=g(x)</math>
:<math>x^2+1=-x^2+3</math>
:<math>2 \cdot x^2=2</math>
:<math> x^2=1</math>
:<math> x=\pm \sqrt{1}</math>
:<math>x=\pm 1</math>
2. Stammfunktionen ermitteln
:<math>F(x)=\frac{1}{3}x^3+x</math>
:<math>G(x)=-\frac{1}{3}x^3+3x</math>
3. Flächeninhalt ermitteln
:<math>\int_{-1}^{1}(f(x)-g(x)) \, dx=F(1)-G(1)-(F(-1)-G(-1))</math>
:<math>=\frac{1}{3} \cdot 1^3+1-(-\frac{1}{3}\cdot 1^3+3 \cdot 1)</math>
:<math>-(\frac{1}{3} \cdot (-1)^3+(-1)-(-\frac{1}{3}\cdot (-1)^3+3 \cdot (-1)))</math>
:<math>=-\frac{8}{3}</math> (orientierter Flächeninhalt)

Der gesuchte Flächeninhalt ist der [[Betragsfunktion|Betrag]] der Zahl und beträgt <span style="color:green"><math>\frac{8}{3}</math></span>.

[[Kategorie:Integralrechnung]]
[[Kategorie:AHR_WuV_Mathe_GK]]

MediaWiki:Common.js

2026-07-09T12:22:14Z

Flbkwikiadmin: Der Seiteninhalt wurde durch einen anderen Text ersetzt: „/* ============================================================ MediaWiki:Common.js – FLBK-Wiki Bereinigte Fassung (Basis: Wikipedia-Common.js). Editier-Komfort, Wikipedia-Infrastruktur & ungenutzte Vorlagen-Skripte entfernt. Hinweis: Gilt NICHT für die mobile Ansicht – dafür MediaWiki:Mobile.js. ============================================================ */ /* Korrekte Sortierung von Umlauten und ß in…“

/* ============================================================
MediaWiki:Common.js – FLBK-Wiki
Bereinigte Fassung (Basis: Wikipedia-Common.js).
Editier-Komfort, Wikipedia-Infrastruktur & ungenutzte
Vorlagen-Skripte entfernt.
Hinweis: Gilt NICHT für die mobile Ansicht – dafür MediaWiki:Mobile.js.
============================================================ */

/* Korrekte Sortierung von Umlauten und ß in sortierbaren Tabellen */
mw.config.set( 'tableSorterCollation', {
'Ä':'A', 'Ö':'O', 'Ü':'U', 'ä':'a', 'ö':'o', 'ü':'u', 'ß':'ss'
} );