# 5.3 Programmierung ## Algorithmen ### Was ist ein Algorithmus? > Ein **Algorithmus** ist eine endliche Folge von eindeutigen Anweisungen zur Lösung eines Problems. ### Eigenschaften ``` Algorithmus-Eigenschaften ├── Endlichkeit → Endlich viele Schritte ├── Eindeutigkeit → Jeder Schritt klar definiert ├── Ausführbarkeit → Jeder Schritt ausführbar ├── Terminiertheit → Algorithmus endet └── Korrektheit → Liefert richtiges Ergebnis ``` --- ## Grundlegende Programmstrukturen ### Sequenz ``` Anweisungen werden nacheinander ausgeführt Schritt 1 ↓ Schritt 2 ↓ Schritt 3 ``` ### Selektion (Verzweigung) ``` Wenn-Dann-Sonst ┌───────────────┐ │ Bed. erfüllt? │ └───────┬───────┘ ╱ ╲ Ja Nein ╲ ╱ ▼ ▼ ┌────────┐ ┌────────┐ │ Block A│ │ Block B│ └────────┘ └────────┘ ``` ### Iteration (Schleife) ``` Wiederholung ┌───────────────┐ │ Bedingung │ └───────┬───────┘ ╱ ╲ wahr falsch ╲ ╱ ▼ ▼ ┌─────────┐ ┌──────┐ │ Block │──►│ Ende │ │ ausführen│ └──────┘ └─────────┘ ``` --- ## Datenstrukturen ### Grundlegende Datentypen | Typ | Beispiel | Speicher | |-----|----------|----------| | Integer | 42 | 4 Byte | | Float | 3.14 | 8 Byte | | Boolean | true/false | 1 Byte | | Char | 'A' | 1 Byte | | String | "Hallo" | variabel | ### Arrays ``` Array - eindimensional [0] [1] [2] [3] [4] 10 20 30 40 50 Zugriff: array[2] → 30 ``` ### Listen ``` Liste - dynamisch Liste namen = ["Max", "Anna", "Peter"] Operationen: - add(Element) → Hinzufügen - remove(Index) → Entfernen - get(Index) → Abrufen - size() → Größe ``` ### Schlüssel-Wert-Paare (Dictionary/Map) ``` Map - Schlüssel-Wert { "Name": "Max", "Alter": 25, "Stadt": "Berlin" } ``` --- ## Algorithmen ### Suchen #### Lineare Suche ``` Suche in ungeordneter Liste Schleife durch alle Elemente → O(n) Zeitkomplexität ``` #### Binäre Suche ``` Suche in sortierter Liste Teile und Herrsche → O(log n) Zeitkomplexität ``` ### Sortieren #### Bubble Sort ``` Vergleiche benachbarte Elemente Tausche wenn in falscher Reihenfolge Beispiel: [5, 3, 8, 1] → [3, 5, 1, 8] → [3, 1, 5, 8] → ... → O(n²) Zeitkomplexität ``` #### Quick Sort ``` Pivot-Element wählen Kleine links, große rechts Rekursiv wiederholen → O(n log n) Durchschnitt ``` --- ## Komplexität ### Big O Notation | Notation | Name | Beispiel | |----------|------|----------| | O(1) | Konstant | Array-Zugriff | | O(log n) | Logarithmisch | Binäre Suche | | O(n) | Linear | Lineare Suche | | O(n log n) | Linearithmisch | Quick Sort | | O(n²) | Quadratisch | Bubble Sort | | O(2^n) | Exponentiell | Brute Force | --- ## Programmiersprachen ### Übersicht | Sprache | Typ | Einsatz | |---------|-----|----------| | **Python** | Interpretiert | Data Science, Web | | **Java** | Kompiliert | Enterprise | | **JavaScript** | Interpretiert | Web, Frontend | | **C#** | Kompiliert | Windows, .NET | | **C/C++** | Kompiliert | Systemnah | ### Sprachkonzepte ``` Programmierparadigmen ├── Imperativ → Anweisungen ├── Prozedural → Funktionen ├── Objektorientiert → Klassen/Objekte ├── Funktional → Funktionen ohne Zustand └── Logisch → Regeln und Fakten ``` --- ## Objektorientierte Programmierung (OOP) ### Grundkonzepte ``` OOP - Prinzipien ├── Kapselung (Encapsulation) ├── Vererbung (Inheritance) ├── Polymorphie └── Abstraktion ``` ### Klasse und Objekt ```python # Klasse (Bauplan) class Auto: # Konstruktor def __init__(self, marke, farbe): self.marke = marke self.farbe = farbe self.geschwindigkeit = 0 # Methode def beschleunigen(self, wert): self.geschwindigkeit += wert def __str__(self): return f"{self.marke}, {self.farbe}" # Objekt (Instanz) mein_auto = Auto("BMW", "rot") mein_auto.beschleunigen(50) ``` ### Vererbung ```python class Tier: def __init__(self, name): self.name = name def essen(self): print("Tier isst") class Hund(Tier): # Vererbung def bellen(self): print("Wuff!") hund = Hund("Bello") hund.essen() # Von Tier geerbt hund.bellen() # Eigene Methode ``` --- ## Qualitätskriterien ### Clean Code Prinzipien ``` Gute Software ├── Lesbarkeit → Gut verständlich ├── Wartbarkeit → Einfach zu ändern ├── Effizienz → Schnell genug ├── Zuverlässigkeit → Keine Fehler └── Sicherheit → Vor Angriffen geschützt ``` ### Namenskonventionen ``` Variablen: camelCase meinName = "Max" Konstanten: UPPER_CASE MAX_ALTER = 100 Funktionen: camelCase def holeDaten(): Klassen: PascalCase class Benutzer: ``` --- ## Querverweise - [[LF5-02-Softwaremodellierung|Zurück: Softwaremodellierung]] - [[LF5-04-Testverfahren|Nächstes Thema: Testverfahren]] - [[LF4-01-Gefahren-Analyse|Sicherheit: Sichere Programmierung]] --- *Stand: 2024*