5.3 KiB
5.3 KiB
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<String> 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
# 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
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
Stand: 2024