Datenstrukturen und Beziehungsdiagramme

Definition: Ways to organize and store data for efficient access and modification.
Types of Data Structures:
- Linear: Elements arranged in a sequence (e.g., Arrays, Linked Lists).
- Non-linear: Elements arranged hierarchically (e.g., Trees, Graphs).
Common Data Structures:
- Array: Fixed-size, contiguous memory allocation; efficient access via index.
- Linked List: Dynamic size; consists of nodes with data and pointers to next nodes.
- Stack: LIFO (Last In, First Out); used in function calls and backtracking algorithms.
- Queue: FIFO (First In, First Out); used in scheduling and buffer management.
- Tree: Hierarchical structure; binary trees are commonly used in searching and sorting.
- Graph: Consists of nodes and edges; used to represent networks, paths, and relationships.
Operations: Insertion, deletion, traversal, searching, and sorting.

Definition: Entity-Relationship Diagrams used to model data relationships.
Components:
- Entities: Objects or things in the system (e.g., Customer, Order).
- Attributes: Properties of entities (e.g., Customer Name, Order Date).
- Relationships: Connections between entities (e.g., Customer places Order).
Types of Relationships:
- One-to-One: One entity is related to one other entity.
- One-to-Many: One entity can relate to multiple entities.
- Many-to-Many: Multiple entities can relate to multiple entities.
Notation: Rectangles for entities, ovals for attributes, diamonds for relationships, lines to connect them.

Definition: A class that cannot be instantiated and may contain abstract methods.
Purpose: To provide a base for subclasses to implement abstract methods.
Characteristics:
- Can include both abstract methods (no implementation) and concrete methods (with implementation).
- Allows for polymorphism; different subclasses can implement methods in diverse ways.
Usage:
- Define common interfaces and behaviors for related classes.
- Enforce certain behaviors in derived classes through abstraction.
Example:
- An abstract class Shape with an abstract method draw(), which must be implemented by subclasses like Circle and Rectangle.

Definition: Strukturen zur Organisation und Speicherung von Daten für effizienten Zugriff und Modifikation.
Typen von Datenstrukturen:
- Linear: Elemente in einer Sequenz angeordnet (z.B. Arrays, verkettete Listen).
- Nicht-linear: Elemente hierarchisch angeordnet (z.B. Bäume, Graphen).
Bekannte Datenstrukturen:
- Array: Fester Größe, kontinuierliche Speicherzuweisung; effizienter Zugriff über den Index.
- Verkettete Liste: Dynamische Größe; besteht aus Knoten mit Daten und Zeigern auf folgende Knoten.
- Stapel: LIFO (Last In, First Out); Verwendung in Funktionsaufrufen und Backtracking-Algorithmen.
- Warteschlange: FIFO (First In, First Out); Verwendung in Planung und Puffermanagement.
- Baum: Hierarchische Struktur; Binärbäume sind häufig in Such- und Sortieralgorithmen.
- Graph: Besteht aus Knoten und Kanten; wird verwendet, um Netzwerke, Wege und Beziehungen darzustellen.
Operationen: Einfügen, Löschen, Traversierung, Suchen und Sortieren.

Definition: Entitäts-Beziehungsdiagramme zur Modellierung von Datenbeziehungen.
Komponenten:
- Entitäten: Objekte oder Dinge im System (z.B. Kunde, Bestellung).
- Attribute: Eigenschaften von Entitäten (z.B. Kundenname, Bestelldatum).
- Beziehungen: Verbindungen zwischen Entitäten (z.B. Kunde bestellt Bestellung).
Typen von Beziehungen:
- Eins-zu-eins: Eine Entität ist mit einer anderen Entität verbunden.
- Eins-zu-viele: Eine Entität kann mit mehreren Entitäten verbunden sein.
- Viele-zu-viele: Mehrere Entitäten können mit mehreren Entitäten verbunden sein.
Notation: Rechtecke für Entitäten, Ellipsen für Attribute, Rauten für Beziehungen und Linien zur Verbindung.

Definition: Eine Klasse, die nicht instanziiert werden kann und abstrakte Methoden enthalten kann.
Zweck: Bereitstellung einer Grundlage für Unterklassen zur Implementierung abstrakter Methoden.
Eigenschaften:
- Kann sowohl abstrakte Methoden (ohne Implementierung) als auch konkrete Methoden (mit Implementierung) enthalten.
- Ermöglicht Polymorphismus; verschiedene Unterklassen können Methoden unterschiedlich implementieren.
Verwendung:
- Definition gemeinsamer Schnittstellen und Verhalten für verwandte Klassen.
- Durch Abstraktion bestimmte Verhaltensweisen in abgeleiteten Klassen erzwingen.
Beispiel: Eine abstrakte Klasse Shape mit einer abstrakten Methode draw(), die von Unterklassen wie Circle und Rectangle implementiert werden muss.