Darstellung von Algorithmen

In dieser Lerneinheit lernst du die wichtigsten Methoden zur visuellen Darstellung von Algorithmen kennen, insbesondere Programmablaufpläne und Flussdiagramme. Du erfährst, wie du komplexe Prozessabläufe mit standardisierten Symbolen und Notationen übersichtlich visualisieren kannst, was dir bei der Dokumentation und Kommunikation von Lösungsansätzen hilft. Anhand eines praktischen Beispiels zur Bestellverarbeitung übst du die professionelle Erstellung von Ablaufdiagrammen.

Einführung

Stell dir vor, ein Online-Shop erhält tausende Bestellungen pro Minute. Wie weiß das System, welche Bestellung angenommen, geprüft oder abgelehnt wird?

Chaos vs. Struktur: Von unstrukturierten Gedanken zum klaren Flussdiagramm — Bildrechte: Ausbildung-in-der-IT.de (KI-unterstützt)

Hinter dieser scheinbar einfachen Entscheidung steckt ein präziser Algorithmus – eine logische Abfolge von Anweisungen, die jeden Schritt der Bestellverarbeitung steuert.

Damit solche Abläufe fehlerfrei funktionieren, müssen sie klar strukturiert und nachvollziehbar dargestellt werden. Genau das leisten Programmablaufpläne (PAP) und Pseudocode. Sie bilden die Brücke zwischen der Idee eines Prozesses und seiner Umsetzung im Quellcode.

In dieser Lerneinheit lernst du, wie Algorithmen systematisch dargestellt, analysiert und anschließend in funktionierenden Code übersetzt werden.

Lernziele

Nach dieser Lerneinheit kannst du:

1. Programmablaufpläne (PAP) verstehen und erstellen Du kannst die logische Struktur eines Algorithmus in einem Flussdiagramm abbilden, inklusive Start-, Prozess-, Entscheidungs- und Endpunkten.

2. Algorithmen in Quellcode umsetzen Du kannst die in einem PAP definierten Abläufe in eine Programmiersprache wie Python, Java oder C++ übersetzen und den Unterschied zwischen verschachtelten Strukturen und Guard Clauses erklären.

3. Kernkonzepte von Rekursion, Iteration und Datenstrukturen anwenden Du verstehst, wie rekursive und iterative Prozesse funktionieren, und kannst grundlegende Datenstrukturen wie Listen und Arrays in Algorithmen einsetzen.

4. Praktische Algorithmen analysieren und implementieren Du kannst reale Szenarien – wie die Berechnung von Versandkosten – in einzelne algorithmische Schritte zerlegen, modular implementieren und deren Funktionsweise nachvollziehbar erklären.

Programmablaufplan für die Bestellverarbeitung

Hinweis: Der Programmablaufplan (PAP) ist laut aktuellem IHK-Prüfungskatalog nicht mehr prüfungsrelevant.

Ein Programmablaufplan (PAP), auch bekannt als Flussdiagramm, ist ein Werkzeug zur Visualisierung von Algorithmen. Es ermöglicht uns, die logische Abfolge der Schritte eines Algorithmus grafisch darzustellen. Wir nutzen diesen Ansatz, um einen Algorithmus für die Verarbeitung von Bestellungen zu konzipieren.

Schritte zur Erstellung des Programmablaufplans

1. Startpunkt definieren: Jedes Flussdiagramm beginnt mit einem Startpunkt (Oval), der den Beginn des Algorithmus markiert.
2. Prozesse identifizieren: Überlege, welche Hauptprozesse (Rechtecke) in der Bestellabwicklung involviert sind. Zum Beispiel:
   • Bestellung aufnehmen
   • Bestellung bestätigen oder ablehnen
3. Entscheidungspunkte einfügen: An bestimmten Punkten (Rauten) muss der Algorithmus Entscheidungen treffen. Zum Beispiel:
   • Ist der Artikel verfügbar?
   • Sind die Kundendaten gültig?
   • Ist die Zahlungsinformation gültig?
4. Endpunkt festlegen: Jedes Flussdiagramm sollte einen klaren Endpunkt (Oval) haben.

Beispiel eines Programmablaufplans

Beispiel eines Programmablaufplans

Im Folgenden findest du den PAP für eine einfache Bestellverarbeitung:

Beispiel eines Programmablaufplans (Bildrechte: Ausbildung in der IT)

Schlüsselelemente des PAP

• Start und Ende markieren den Beginn und das Ende des Algorithmus (Terminatoren, oft Ovale).
• Prozesse repräsentieren Aufgaben, Operationen oder Tätigkeiten (Rechtecke).
• Entscheidungen sind Punkte, an denen basierend auf einer Bedingung unterschiedliche Wege eingeschlagen werden (Rauten).

Umsetzung in Code

Um den PAP in tatsächlichen Quellcode umzusetzen, müsstest du die Prozesse und Entscheidungen in entsprechende Code-Blöcke übersetzen. Die direkte Übersetzung der verschachtelten Entscheidungen (wie im PAP) führt oft zu tief verschachteltem Code:

1. Verschachtelte Umsetzung (Direkte PAP-Übersetzung)

start
aufnahme_bestellung()
 
if artikel_verfuegbar():
    if kundendaten_gueltig():
        if zahlungsinformation_gueltig():
            bestellung_bestätigen()
        else:
            bestellung_ablehnen()
    else:
        bestellung_ablehnen()
else:
    bestellung_ablehnen()
 
ende

Dieser Stil mit vielen if-else-Ebenen kann schnell unübersichtlich werden.

Umsetzung in Code

2. Saubere Umsetzung (mit “Guard Clauses”)

Ein modernerer Ansatz ist die Verwendung von “Guard Clauses” (Wächter-Klauseln). Hier prüft man zuerst alle Fehlerfälle und bricht sofort ab. Der “Erfolgsfall” (Happy Path) steht am Ende, klar und unverschachtelt.

start
aufnahme_bestellung()
 
if artikel_verfuegbar() == false:
    bestellung_ablehnen()
    ende // Prozess hier beenden
 
if kundendaten_gueltig() == false:
    bestellung_ablehnen()
    ende // Prozess hier beenden
 
if zahlungsinformation_gueltig() == false:
    bestellung_ablehnen()
    ende // Prozess hier beenden
 
// Erfolgsfall: Alle Prüfungen bestanden
bestellung_bestätigen()
ende

Erklärung dieser Methode: Dieser “flache” Code ist leichter zu lesen. Man sieht sofort am Anfang alle Bedingungen, die zu einem Abbruch (bestellung_ablehnen) führen. Die eigentliche Hauptfunktion (bestellung_bestätigen()) wird nur erreicht, wenn alle “Wächter” passiert wurden.

Fazit

Ein Programmablaufplan ist ein essenzielles Werkzeug in der initialen Phase der Softwareentwicklung, insbesondere wenn es darum geht, komplexe Algorithmen wie die Verarbeitung von Bestellungen zu entwerfen. Er dient nicht nur der Visualisierung des Algorithmus für das Entwicklungsteam, sondern erleichtert auch die Kommunikation mit Stakeholdern, die möglicherweise nicht technisch versiert sind.

Umsetzung von Algorithmen in Quellcode

Wenn wir von der Umsetzung von Algorithmen in Quellcode sprechen, meinen wir die Übersetzung der theoretischen Algorithmus-Konzepte in eine für den Computer verständliche Sprache, wie Python, Java oder C++. Hier sehen wir uns praktische Beispiele an, um zu verstehen, wie Algorithmen in verschiedene Programmiersprachen umgesetzt werden können.

Beispiel 1: Suchalgorithmus (Lineare Suche) in Python

def lineare_suche(liste, ziel):
    for index, wert in enumerate(liste):
        if wert == ziel:
            return index
    return -1

Erklärung des Codes: Diese Funktion sucht eine Liste (liste) nach einem bestimmten Wert (ziel) ab, indem sie bei 0 anfängt und jeden Eintrag einzeln prüft.

• for index, wert in enumerate(liste): Diese Schleife geht die Liste Element für Element durch. Sie gibt uns den Wert (wert) und dessen Position (index) bei jedem Schritt.
• if wert == ziel: Hier prüft der Code, ob das aktuelle Element (wert) das ist, wonach wir suchen (ziel).
• return index: Wenn das Ziel gefunden wird, gibt die Funktion sofort die Position (index) zurück und stoppt.
• return -1: Wenn die Schleife komplett durchläuft, ohne das Ziel zu finden, gibt die Funktion -1 zurück, als Signal, dass der Wert nicht in der Liste enthalten ist.

Umsetzung von Algorithmen in Quellcode

Beispiel 2: Sortieralgorithmus (Bubble Sort) in Java

public void bubbleSort(int arr[]) {
    int n = arr.length;
    for (int i = 0; i < n-1; i++)
        for (int j = 0; j < n-i-1; j++)
            if (arr[j] > arr[j+1]) {
                // Tausche arr[j+1] und arr[j]
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
}

Erklärung des Codes: Diese Funktion sortiert eine Liste von Zahlen (arr) von der kleinsten zur größten. Sie funktioniert, indem sie immer wieder durch die Liste geht und benachbarte Zahlen vergleicht.

• Die äußere Schleife (for i...) sorgt dafür, dass der gesamte Vorgang oft genug wiederholt wird, bis alles sortiert ist.
• Die innere Schleife (for j...) geht durch die Liste und vergleicht zwei benachbarte Zahlen: die an Position j und die an Position j+1.
• if (arr[j] > arr[j+1]): Wenn die linke Zahl (arr[j]) größer ist als die rechte (arr[j+1]), sind sie in der falschen Reihenfolge.
• Der Tausch: Die drei Zeilen mit temp (eine temporäre Hilfsvariable) sorgen dafür, dass die beiden Zahlen ihre Plätze tauschen.
• Dieser Vorgang “drückt” die größten Zahlen wie Luftblasen (Bubbles) langsam an das Ende der Liste, bis die gesamte Liste sortiert ist.

Umsetzung von Algorithmen in Quellcode

Beispiel 3: Rekursiver Algorithmus (Fakultätsberechnung) in C++

#include<iostream>
using namespace std;
 
int fakultaet(int n) {
    if (n <= 1) return 1;
    return n * fakultaet(n - 1);
}
 
int main() {
    int nummer;
    cout << "Gib eine positive Zahl ein: ";
    cin >> nummer;
    cout << "Fakultät von " << nummer << " ist " << fakultaet(nummer) << endl;
    return 0;
}

Erklärung des Codes (Fokus auf fakultaet): Diese Funktion berechnet die Fakultät einer Zahl (z.B. 5! = 5 * 4 * 3 * 2 * 1). Sie ist “rekursiv”, das heißt, sie ruft sich selbst auf, um das Problem zu lösen.

• int fakultaet(int n): Definiert die Funktion, die eine Zahl n entgegennimmt.
• if (n <= 1) return 1;: Das ist die Abbruchbedingung. Die Fakultät von 1 (oder 0) ist 1. Wenn die Funktion hier ankommt, stoppt sie die Rekursion und gibt 1 zurück.
• return n * fakultaet(n - 1);: Das ist der rekursive Aufruf. Wenn n größer als 1 ist, gibt die Funktion n multipliziert mit dem Ergebnis von fakultaet(n-1) zurück.
• Ablauf (Beispiel fakultaet(3)):
  1. fakultaet(3) ruft fakultaet(2) auf. (Es wartet auf 3 * ...)
  2. fakultaet(2) ruft fakultaet(1) auf. (Es wartet auf 2 * ...)
  3. fakultaet(1) trifft die Abbruchbedingung und gibt 1 zurück (an fakultaet(2)).
  4. fakultaet(2) rechnet 2 * 1 = 2 und gibt 2 zurück (an fakultaet(3)).
  5. fakultaet(3) rechnet 3 * 2 = 6 und gibt 6 als Endergebnis zurück.

Wichtige Begriffe und Tipps

Wichtige Begriffe und Konzepte

• Rekursion: Eine Funktion, die sich selbst aufruft, um ein Problem in kleineren Schritten zu lösen.
• Iteration: Ein Prozess, um eine Abfolge von Anweisungen wiederholt durchzuführen (z.B. eine for-Schleife).
• Sortierung und Suche: Grundlegende Operationen, um Daten zu organisieren bzw. zu durchsuchen.
• Datenstrukturen: Wichtige Konzepte, wie Listen und Arrays, die in Algorithmen genutzt werden.

Praktische Tipps

• Verwende aussagekräftige Variablennamen, um den Quellcode verständlicher zu machen.
• Zugrunde liegende Konzepte wie Schleifen und bedingte Anweisungen solltest du gut verstehen, bevor du zu komplexeren Algorithmen übergehst.
• Experimentiere mit eigenen Daten und leicht modifizierten Algorithmen, um ein tieferes Verständnis zu entwickeln.

Die Umsetzung eines Algorithmus in Quellcode ist ein wichtiger Schritt vom theoretischen Modell zur tatsächlichen Anwendung. Mit Übung und Verständnis für die Grundlagen wirst du in der Lage sein, effiziente und effektive Code-Lösungen für komplexe Probleme zu entwickeln.

⏳ Lädt Dataview-Inhalt...

Darstellung eines Algorithmus zur Berechnung von Versandkosten

Die Berechnung von Versandkosten in E-Commerce-Systemen ist ein gängiges Szenario, bei dem Algorithmen zum Einsatz kommen. Die Versandkosten können dabei auf Basis verschiedener Faktoren wie Gewicht, Maße, Zielort und Versandart (Standard, Express) berechnet werden.

Versandkostenberechnung: Grundkonzept

Der Algorithmus zur Berechnung der Versandkosten muss zunächst die verschiedenen Parameter definieren, die die Kosten beeinflussen:

• Gewicht (G): Das Gesamtgewicht der zu versendenden Artikel.
• Maße (L, B, H): Länge (L), Breite (B) und Höhe (H) des Pakets.
• Zielort (Z): Die Zielregion, die unterschiedliche Kostenfaktoren haben kann.
• Versandart (V): Auswahl zwischen Standard- und Expressversand.

Die Berechnung könnte eine Basisgebühr enthalten, die je nach Versandart variiert, und zusätzliche Gebühren, die basierend auf Gewicht und Maßen hinzugefügt werden.

Pseudocode

Der folgende Pseudocode skizziert eine einfache Struktur zur Berechnung der Versandkosten:

function berechneVersandkosten(G, L, B, H, Z, V):
    basisKosten = holeBasisKosten(V, Z)
    gewichtsZuschlag = berechneGewichtsZuschlag(G)
    groessenZuschlag = berechneGroessenZuschlag(L, B, H)
    gesamtKosten = basisKosten + gewichtsZuschlag + groessenZuschlag
    return gesamtKosten
 
function holeBasisKosten(V, Z):
    // Bestimme die Basisgebühr basierend auf Versandart und Zielort
    ...
 
function berechneGewichtsZuschlag(G):
    // Berechne den Zuschlag basierend auf dem Gewicht
    ...
 
function berechneGroessenZuschlag(L, B, H):
    // Berechne den Zuschlag basierend auf den Maßen
    ...

Erklärung des Pseudocodes: Dieser Code ist ein allgemeiner Plan (keine echte Programmiersprache), der die Logik aufzeigt.

• function berechneVersandkosten(...): Dies ist die Hauptanleitung. Sie benötigt alle Infos (Gewicht, Maße etc.) als Input.
• Sie ruft drei spezialisierte Hilfsfunktionen auf: holeBasisKosten, berechneGewichtsZuschlag und berechneGroessenZuschlag.
• Jede Hilfsfunktion kümmert sich nur um ihren eigenen Teil (z.B. die Basisgebühr anhand von Versandart und Zielort zu finden).
• Am Ende addiert die Hauptfunktion alle Einzelkosten (basisKosten, gewichtsZuschlag, groessenZuschlag) zusammen und gibt die gesamtKosten zurück.

Beispiel: Versandkostenberechnung in Python

Ein praktisches Beispiel in Python kann die Anwendung des Pseudocodes verdeutlichen:

def berechne_versandkosten(gewicht, laenge, breite, hoehe, zielort, versandart):
    basis_kosten = hole_basis_kosten(versandart, zielort)
    gewichts_zuschlag = berechne_gewichts_zuschlag(gewicht)
    groessen_zuschlag = berechne_groessen_zuschlag(laenge, breite, hoehe)
    gesamt_kosten = basis_kosten + gewichts_zuschlag + groessen_zuschlag
    return gesamt_kosten
 
def hole_basis_kosten(versandart, zielort):
    # Fiktive Implementierung: In echt würde hier z.B. eine Datenbank
    # oder eine komplexe Preis-Tabelle abgefragt werden.
    return 5.0  # Feste Basisgebühr von 5.0 Euro
 
def berechne_gewichts_zuschlag(gewicht):
    # Fiktive Implementierung: 0.5 Euro pro Kilogramm
    return gewicht * 0.5
 
def berechne_groessen_zuschlag(laenge, breite, hoehe):
    # Fiktive Implementierung: 0.02 Euro pro Kubikzentimeter
    volumen = laenge * breite * hoehe
    return volumen * 0.02
 
# Beispielaufruf
kosten = berechne_versandkosten(2, 30, 20, 15, 'Berlin', 'Standard')
print(f"Die Versandkosten betragen: {kosten} Euro")

Erklärung des Codes: Dies ist die Umsetzung des Pseudocodes in Python. Die Logik ist identisch, aber jetzt mit konkreten (fiktiven) Berechnungen:

• hole_basis_kosten(...): Gibt hier einfach immer 5.0 (Euro) zurück, egal was der Zielort oder die Versandart ist.
• berechne_gewichts_zuschlag(...): Berechnet einen Zuschlag von 0.50 Euro pro Gewichtseinheit (z.B. pro Kilo).
• berechne_groessen_zuschlag(...): Berechnet das Volumen (laenge * breite * hoehe) und multipliziert es mit 0.02 (z.B. 2 Cent pro Kubikzentimeter).
• berechne_versandkosten(...): Addiert die Ergebnisse dieser drei Funktionen (5.0 + Gewichtszuschlag + Größenzuschlag).
• Beispielaufruf: Beim Aufruf mit 2kg, 30x20x15cm wird gerechnet:
  • Basis: 5.0
  • Gewicht: 2 * 0.5 = 1.0
  • Größe: (30 * 20 * 15) * 0.02 = 9000 * 0.02 = 180.0
  • Gesamt: 5.0 + 1.0 + 180.0 = 186.0 Euro

Dieses Beispiel stellt eine Grundlage dar, die an spezifische Geschäftslogiken und Tariftabellen angepasst werden kann. Es demonstriert, wie man mit einfachen Funktionen und Berechnungen einen nützlichen Algorithmus zur Versandkostenberechnung entwickeln kann.

⏳ Lädt Dataview-Inhalt...

Zusammenfassung

Zusammenfassung:

Programmablaufplan und Bestellverarbeitung

Ein Programmablaufplan (PAP) visualisiert die logische Abfolge eines Algorithmus. Er zeigt Prozesse, Entscheidungen und den Ablauf eines Systems, beispielsweise bei der Bestellverarbeitung.

• Funktion: Der PAP dient der grafischen Darstellung von Abläufen und erleichtert die Kommunikation zwischen Entwicklern und Stakeholdern.

• Hauptbestandteile:

  • Start/Ende: Markieren Beginn und Abschluss des Algorithmus.
  • Prozesse: Zeigen konkrete Arbeitsschritte (z. B. Bestellung aufnehmen).
  • Entscheidungen: Bilden Bedingungen ab (z. B. Artikel verfügbar?).

• Zwei Codevarianten:

  • Verschachtelte If-Struktur: Direkte Umsetzung des PAP mit mehreren Ebenen von Bedingungen.
  • Guard Clauses: Moderne Variante, die Fehlerfälle direkt abfängt und den Code flach, klar und lesbar hält.

• Erkenntnis: Guard Clauses führen zu besserer Lesbarkeit und reduzieren die Fehleranfälligkeit.

Umsetzung von Algorithmen in Quellcode

Die Übersetzung eines Algorithmus in Quellcode überführt theoretische Abläufe in eine lauffähige Form.

• Suchalgorithmus (Lineare Suche):

  • Durchläuft eine Liste Schritt für Schritt und vergleicht jedes Element mit einem Zielwert.
  • Gibt die Position zurück, falls der Wert gefunden wird, sonst -1.

• Sortieralgorithmus (Bubble Sort):

  • Vergleicht benachbarte Elemente einer Liste und tauscht sie bei falscher Reihenfolge.
  • Wiederholt den Vorgang, bis die Liste sortiert ist.

• Rekursiver Algorithmus (Fakultät in C++):

  • Eine Funktion ruft sich selbst auf, bis eine Abbruchbedingung erreicht ist.
  • Verdeutlicht das Prinzip der Rekursion, bei der Probleme in kleinere Teilprobleme zerlegt werden.

Zentrale Begriffe:

• Rekursion: Selbstaufruf einer Funktion zur Lösung eines Teilproblems.
• Iteration: Wiederholung eines Prozesses (z. B. Schleifen).
• Datenstrukturen: Grundlage für effiziente Datenorganisation, z. B. Listen oder Arrays.

---