🧮 Algorithmen Grundlagen I

Tauschen und Extremwerte

Die wichtigsten Bausteine für Algorithmen

Grundlagen der Programmierung

🤔 Warum brauchen wir Algorithmen?

Ein Algorithmus ist eine Schritt-für-Schritt-Anleitung zur Lösung eines Problems.

Wie ein Kochrezept - aber für den Computer!

                    Heute lernen wir:
                    🔄 Werte tauschen (Swap)
⬆️ Maximum finden
⬇️ Minimum finden
📊 Schleifen: Aufwärts vs. Abwärts

                

🔁 Schleifen: Aufwärts oder Abwärts?

Wann zählen wir aufwärts und wann abwärts?

⬆️ Aufwärts (0 → n)

for (int i = 0; i < n; i++) { // Von Anfang bis Ende }

✅ Standard für Arrays durchlaufen
✅ Summe berechnen
✅ Elemente zählen

⬇️ Abwärts (n → 0)

for (int i = n - 1; i >= 0; i--) { // Von Ende bis Anfang }

✅ Array umgekehrt ausgeben
✅ Countdown
✅ Elemente löschen

⬆️ Beispiel: Aufwärts zählen

#include <stdio.h>

int main()
{
    int zahlen[5] = {10, 20, 30, 40, 50};

    printf("Array vorwärts:\n");
    for (int i = 0; i < 5; i++)
    {
        printf("zahlen[%d] = %d\n", i, zahlen[i]);
    }

    return 0;
}

Array vorwärts: zahlen[0] = 10 zahlen[1] = 20 zahlen[2] = 30 zahlen[3] = 40 zahlen[4] = 50

⬇️ Beispiel: Abwärts zählen

#include <stdio.h>

int main()
{
    int zahlen[5] = {10, 20, 30, 40, 50};

    printf("Array rückwärts:\n");
    for (int i = 4; i >= 0; i--)
    {
        printf("zahlen[%d] = %d\n", i, zahlen[i]);
    }

    return 0;
}

Array rückwärts: zahlen[4] = 50 zahlen[3] = 40 zahlen[2] = 30 zahlen[1] = 20 zahlen[0] = 10

🚀 Praktisch: Countdown

#include <stdio.h>

int main()
{
    printf("Raketenstart!\n\n");

    /* Countdown von 10 bis 1 */
    for (int i = 10; i >= 1; i--)
    {
        printf("%d...\n", i);
    }

    printf("\n🚀 LIFTOFF!\n");

    return 0;
}

Raketenstart! 10... 9... 8... ... 1... 🚀 LIFTOFF!

🔄 Das Tausch-Problem

Wie tauschen wir die Werte von zwei Variablen?

5 a

⟷

3 b

⚠️ Das funktioniert NICHT:

a = b; // a ist jetzt 3, aber 5 ist verloren! b = a; // b ist auch 3 - beide sind gleich!

Problem: Der ursprüngliche Wert von a wird überschrieben, bevor wir ihn speichern!

💡 Die Lösung: Hilfsvariable

Wir brauchen einen "Zwischenspeicher" - wie beim Umräumen von Gläsern!

Schritt 1: temp = a

5a

3b

5temp

Schritt 2: a = b

3a

3b

5temp

Schritt 3: b = temp

3a

5b

5temp

🔄 Swap im Code

#include <stdio.h>

int main()
{
    int a = 5;
    int b = 3;
    int temp;

    printf("Vorher: a = %d, b = %d\n", a, b);

    /* Tauschen mit Hilfsvariable */
    temp = a;    // 1. Wert von a sichern
    a = b;       // 2. b nach a kopieren
    b = temp;    // 3. Gesicherten Wert nach b

    printf("Nachher: a = %d, b = %d\n", a, b);

    return 0;
}

Vorher: a = 5, b = 3 Nachher: a = 3, b = 5

✅ Merke: Swap braucht IMMER 3 Schritte und eine Hilfsvariable!

🔄 Swap in Arrays

Das gleiche Prinzip funktioniert auch mit Array-Elementen:

#include <stdio.h>

int main()
{
    int zahlen[5] = {10, 20, 30, 40, 50};
    int temp;

    printf("Vorher: %d, %d, %d, %d, %d\n",
           zahlen[0], zahlen[1], zahlen[2], zahlen[3], zahlen[4]);

    /* Element 0 und Element 4 tauschen */
    temp = zahlen[0];
    zahlen[0] = zahlen[4];
    zahlen[4] = temp;

    printf("Nachher: %d, %d, %d, %d, %d\n",
           zahlen[0], zahlen[1], zahlen[2], zahlen[3], zahlen[4]);

    return 0;
}

Vorher: 10, 20, 30, 40, 50 Nachher: 50, 20, 30, 40, 10

⬆️ Maximum finden

Wie finden wir die größte Zahl in einem Array?

7[0]

3[1]

12[2]

5[3]

9[4]

                    💡 Die Idee:
                    Nimm das erste Element als "bisheriges Maximum"
Gehe durch alle weiteren Elemente
Wenn ein Element größer ist → neues Maximum
Am Ende haben wir das Maximum!

                

⬆️ Maximum: Schritt für Schritt

Schritt	Element	Vergleich	max
Start	zahlen[0] = 7	-	7
i = 1	zahlen[1] = 3	3 > 7? ❌ Nein	7
i = 2	zahlen[2] = 12	12 > 7? ✅ Ja!	12
i = 3	zahlen[3] = 5	5 > 12? ❌ Nein	12
i = 4	zahlen[4] = 9	9 > 12? ❌ Nein	12
Ende	-	-	12 ✓

⬆️ Maximum im Code

#include <stdio.h>

int main()
{
    int zahlen[5] = {7, 3, 12, 5, 9};
    int max;

    /* Erstes Element als Startwert */
    max = zahlen[0];

    /* Alle weiteren Elemente prüfen */
    for (int i = 1; i < 5; i++)
    {
        if (zahlen[i] > max)
        {
            max = zahlen[i];
        }
    }

    printf("Das Maximum ist: %d\n", max);

    return 0;
}

Das Maximum ist: 12

❓ Warum beginnt die Schleife bei i = 1?

⚠️ Nur beim Maximum/Minimum-Algorithmus!

Der Grund: Wir setzen max = zahlen[0] vor der Schleife als Startwert.

→ Element [0] wurde also schon verwendet! Es wäre sinnlos, zahlen[0] > zahlen[0] zu prüfen.

✅ Effizient: Start bei i = 1

max = zahlen[0]; // Index 0 ist Startwert for (int i = 1; i < n; i++) // Ab Index 1

n-1 Vergleiche (optimal)

😐 Auch korrekt: Start bei i = 0

max = zahlen[0]; for (int i = 0; i < n; i++) // Prüft auch [0]

n Vergleiche (1 unnötig: zahlen[0] > zahlen[0])

⚠️ Wichtig: Dies gilt NUR für Max/Min-Suche! Bei anderen Algorithmen (z.B. Array ausgeben, Summe berechnen) startet man meist bei i = 0, weil alle Elemente durchlaufen werden müssen.

⬇️ Minimum finden

Fast identisch zum Maximum - nur das Vergleichszeichen ändert sich!

#include <stdio.h>

int main()
{
    int zahlen[5] = {7, 3, 12, 5, 9};
    int min;

    /* Erstes Element als Startwert */
    min = zahlen[0];

    /* Alle weiteren Elemente prüfen */
    for (int i = 1; i < 5; i++)
    {
        if (zahlen[i] < min)  // Nur dieses Zeichen ändert sich!
        {
            min = zahlen[i];
        }
    }

    printf("Das Minimum ist: %d\n", min);

    return 0;
}

Das Minimum ist: 3

📊 Min UND Max gleichzeitig

#include <stdio.h>

int main()
{
    int zahlen[5] = {7, 3, 12, 5, 9};
    int min, max;

    /* Beide mit erstem Element initialisieren */
    min = zahlen[0];
    max = zahlen[0];

    for (int i = 1; i < 5; i++)
    {
        if (zahlen[i] < min)
            min = zahlen[i];

        if (zahlen[i] > max)
            max = zahlen[i];
    }

    printf("Minimum: %d\n", min);
    printf("Maximum: %d\n", max);
    printf("Spannweite: %d\n", max - min);

    return 0;
}

Minimum: 3 Maximum: 12 Spannweite: 9

📍 Position des Maximums finden

Manchmal brauchen wir nicht nur den Wert, sondern auch wo er steht:

#include <stdio.h>

int main()
{
    int zahlen[5] = {7, 3, 12, 5, 9};
    int maxPos = 0;  // Position des Maximums

    for (int i = 1; i < 5; i++)
    {
        if (zahlen[i] > zahlen[maxPos])
        {
            maxPos = i;  // Neue Position merken
        }
    }

    printf("Maximum %d steht an Position %d\n",
           zahlen[maxPos], maxPos);

    return 0;
}

Maximum 12 steht an Position 2

📝 Praxisbeispiel: Beste und schlechteste Note

#include <stdio.h>

int main()
{
    int noten[6] = {2, 1, 3, 2, 4, 1};
    int beste = noten[0];
    int schlechteste = noten[0];

    for (int i = 1; i < 6; i++)
    {
        if (noten[i] < beste)        // Kleinere Note = besser!
            beste = noten[i];
        if (noten[i] > schlechteste) // Größere Note = schlechter!
            schlechteste = noten[i];
    }

    printf("Beste Note: %d\n", beste);
    printf("Schlechteste Note: %d\n", schlechteste);

    return 0;
}

Beste Note: 1 Schlechteste Note: 4

🧠 Quiz: Swap

Was ist der Wert von a und b nach diesem Code?

int a = 10, b = 20, temp; temp = a; a = b; b = temp;

A) a = 10, b = 20

B) a = 20, b = 10

C) a = 20, b = 20

D) a = 10, b = 10

✅ Lösung: Swap

Antwort B: a = 20, b = 10

Die Werte wurden erfolgreich getauscht!

Schritt für Schritt:

Zeile	a	b	temp
Anfang	10	20	?
temp = a	10	20	10
a = b	20	20	10
b = temp	20	10	10

🧠 Quiz: Maximum

Was gibt dieses Programm aus?

int arr[4] = {5, 5, 5, 5}; int max = arr[0]; for (int i = 1; i < 4; i++) { if (arr[i] > max) max = arr[i]; } printf("%d", max);

A) 0

B) 4

C) 5

D) 20

✅ Lösung: Maximum

Antwort C: 5

Alle Elemente sind gleich → das Maximum ist 5.

💡 Wichtig zu verstehen:

max = arr[0] → max wird 5
Schleife prüft: 5 > 5? Nein → max bleibt 5
Der Algorithmus funktioniert auch bei gleichen Werten!

🧠 Quiz: Schleifenrichtung

Welche Ausgabe erzeugt diese Schleife?

for (int i = 3; i >= 1; i--) { printf("%d ", i); }

A) 1 2 3

B) 3 2 1

C) 3 2 1 0

D) 0 1 2 3

✅ Lösung: Schleifenrichtung

Antwort B: 3 2 1

Ablauf:

i	i >= 1?	Ausgabe	Danach
3	✅ Ja	3	i-- → 2
2	✅ Ja	2	i-- → 1
1	✅ Ja	1	i-- → 0
0	❌ Nein	-	Schleife endet

📋 Zusammenfassung: Swap

🔄 Werte tauschen

/* Standard-Swap mit Hilfsvariable */ int temp = a; a = b; b = temp;

✅ Immer 3 Schritte
✅ Hilfsvariable nötig (temp)
✅ Funktioniert für alle Datentypen
✅ Wichtig für Sortieralgorithmen

📋 Zusammenfassung: Min/Max

⬆️ Maximum

max = arr[0]; for (i = 1; i < n; i++) if (arr[i] > max) max = arr[i];

⬇️ Minimum

min = arr[0]; for (i = 1; i < n; i++) if (arr[i] < min) min = arr[i];

                    💡 Das Muster:
                    Erstes Element als Startwert nehmen
Alle weiteren Elemente durchgehen
Bei besserem Wert → aktualisieren

                

📋 Zusammenfassung: Schleifenrichtung

⬆️ Aufwärts (Standard)

for (i = 0; i < n; i++)

• Array durchlaufen
• Summe berechnen
• Elemente zählen
• Min/Max finden

⬇️ Abwärts (Speziell)

for (i = n-1; i >= 0; i--)

• Rückwärts ausgeben
• Countdown
• Elemente entfernen
• Palindrom prüfen

⚠️ Achtung bei Abwärts: Die Bedingung ist i >= 0 (nicht i > 0), sonst wird Element [0] übersprungen!

🔮 Nächste Vorlesung

Algorithmen Grundlagen II: Akkumulieren

➕ Summe berechnen
📊 Durchschnitt berechnen
🔢 Elemente zählen
✖️ Produkt berechnen
🎯 Kombinierte Muster

Heute gelernt: Swap, Maximum, Minimum, Schleifenrichtungen
Diese Bausteine brauchen wir für fast jeden Algorithmus!